Zelda Classic Coverage Report


Directory: src/
File: src/zc/script_drawing.cpp
Date: 2022-11-29 04:45:57
Exec Total Coverage
Lines: 19 4762 0.4%
Functions: 2 104 1.9%
Branches: 5 2676 0.2%

Line Branch Exec Source
1 // This program is free software; you can redistribute it and/or modify it under the terms of the
2 // modified version 3 of the GNU General Public License. See License.txt for details.
3
4 //! ritate_sprite_trans doesn't seem to be supported by or allegro header !?
5
6 //glibc 2.28 and later require this: -Z
7 #ifdef __GNUG__
8 #define ALLEGRO_NO_FIX_ALIASES
9 #endif
10
11 #define LOG_BMPBLIT_LEVEL 0
12 #include "precompiled.h" //always first
13
14 #include "base/allegro_wrapper.h"
15 #include "script_drawing.h"
16 11 #include "rendertarget.h"
17 #include "maps.h"
18 #include "tiles.h"
19 #include "zelda.h"
20 #include "ffscript.h"
21 #include "base/util.h"
22 #include "subscr.h"
23 #include "drawing.h"
24 using namespace util;
25 extern FFScript FFCore;
26 extern ZModule zcm;
27 extern refInfo *ri;
28 extern script_bitmaps scb;
29 #include <stdio.h>
30 #include <fstream>
31
32 #define DegtoFix(d) ((d)*0.7111111111111)
33 #define RadtoFix(d) ((d)*40.743665431525)
34
35 inline double sd_log2( double n )
36 {
37 // log(n)/log(2) is log2.
38 double v = log( (double)n ) / log( (double)2 );
39 return v;
40 }
41
42 inline bool isPowerOfTwo(int32_t n)
43 {
44 if(n==0)
45 return false;
46
47 return (ceil(sd_log2(n)) == floor(sd_log2(n)));
48 }
49
50
51
52 template<class T> inline
53 fixed degrees_to_fixed(T d)
54 {
55 return ftofix(DegtoFix(d));
56 }
57 template<class T> inline
58 fixed radians_to_fixed(T d)
59 {
60 return ftofix(RadtoFix(d));
61 }
62
63 BITMAP* ScriptDrawingBitmapPool::_parent_bmp = 0;
64
65
66
67 FONT *get_zc_font(int32_t index)
68 {
69 //return getfont(index);
70 switch(index)
71 {
72 default:
73 return zfont;
74
75 case font_z3font:
76 return z3font;
77
78 case font_z3smallfont:
79 return z3smallfont;
80
81 case font_deffont:
82 return deffont;
83
84 case font_lfont:
85 return lfont;
86
87 case font_lfont_l:
88 return lfont_l;
89
90 case font_pfont:
91 return pfont;
92
93 case font_mfont:
94 return mfont;
95
96 case font_ztfont:
97 return ztfont;
98
99 case font_sfont:
100 return sfont;
101
102 case font_sfont2:
103 return sfont2;
104
105 case font_spfont:
106 return spfont;
107
108 case font_ssfont1:
109 return ssfont1;
110
111 case font_ssfont2:
112 return ssfont2;
113
114 case font_ssfont3:
115 return ssfont3;
116
117 case font_ssfont4:
118 return ssfont4;
119
120 case font_gblafont:
121 return gblafont;
122
123 case font_goronfont:
124 return goronfont;
125
126 case font_zoranfont:
127 return zoranfont;
128
129 case font_hylian1font:
130 return hylian1font;
131
132 case font_hylian2font:
133 return hylian2font;
134
135 case font_hylian3font:
136 return hylian3font;
137
138 case font_hylian4font:
139 return hylian4font;
140
141 case font_gboraclefont:
142 return gboraclefont;
143
144 case font_gboraclepfont:
145 return gboraclepfont;
146
147 case font_dsphantomfont:
148 return dsphantomfont;
149
150 case font_dsphantompfont:
151 return dsphantompfont;
152 case font_atari800font: return atari800font;
153 case font_acornfont: return acornfont;
154 case font_adosfont: return adosfont;
155 case font_baseallegrofont: return baseallegrofont;
156 case font_apple2font: return apple2font;
157 case font_apple280colfont: return apple280colfont;
158 case font_apple2gsfont: return apple2gsfont;
159 case font_aquariusfont: return aquariusfont;
160 case font_atari400font: return atari400font;
161 case font_c64font: return c64font;
162 case font_c64hiresfont: return c64hiresfont;
163 case font_cgafont: return cgafont;
164 case font_cocofont: return cocofont;
165 case font_coco2font: return coco2font;
166 case font_coupefon: return coupefont;
167 case font_cpcfon: return cpcfont;
168 case font_fantasyfon: return fantasyfont;
169 case font_fdskanafon: return fdskanafont;
170 case font_fdslikefon: return fdslikefont;
171 case font_fdsromanfon: return fdsromanfont;
172 case font_finalffont: return finalffont;
173 case font_futharkfont: return futharkfont;
174 case font_gaiafont: return gaiafont;
175 case font_hirafont: return hirafont;
176 case font_jpfont: return jpfont;
177 case font_kongfont: return kongfont;
178 case font_manafont: return manafont;
179 case font_mlfont: return mlfont;
180 case font_motfont: return motfont;
181 case font_msxmode0font: return msxmode0font;
182 case font_msxmode1font: return msxmode1font;
183 case font_petfont: return petfont;
184 case font_pstartfont: return pstartfont;
185 case font_saturnfont: return saturnfont;
186 case font_scififont: return scififont;
187 case font_sherwoodfont: return sherwoodfont;
188 case font_sinqlfont: return sinqlfont;
189 case font_spectrumfont: return spectrumfont;
190 case font_speclgfont: return speclgfont;
191 case font_ti99font: return ti99font;
192 case font_trsfont: return trsfont;
193 case font_z2font: return z2font;
194 case font_zxfont: return zxfont;
195 case font_lisafont: return lisafont;
196 }
197 }
198
199
200 class TileHelper
201 {
202 public:
203
204 static void OldPutTile(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, byte skiprows=0)
205 {
206 // Past the end of the tile page?
207 if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
208 {
209 byte w2=(tile+w)%TILES_PER_ROW;
210 OldPutTile(_Dest, tile, x, y, w-w2, h, color, flip);
211 OldPutTile(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip);
212 return;
213 }
214
215 switch(flip)
216 {
217 case 1:
218 for(int32_t j=0; j<h; j++)
219 for(int32_t k=w-1; k>=0; k--)
220 oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip);
221
222 break;
223
224 case 2:
225 for(int32_t j=h-1; j>=0; j--)
226 for(int32_t k=0; k<w; k++)
227 oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip);
228
229 break;
230
231 case 3:
232 for(int32_t j=h-1; j>=0; j--)
233 for(int32_t k=w-1; k>=0; k--)
234 oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip);
235
236 break;
237
238 case 0:
239 default:
240 for(int32_t j=0; j<h; j++)
241 for(int32_t k=0; k<w; k++)
242 oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip);
243
244 break;
245 }
246 }
247
248 static void OverTile(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, byte skiprows=0)
249 {
250 overtileblock16(_Dest,tile,x,y,w,h,color,flip,skiprows);
251 }
252
253 static void OverTileCloaked(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t flip, byte skiprows=0)
254 {
255 if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
256 {
257 byte w2=(tile+w)%TILES_PER_ROW;
258 OverTileCloaked(_Dest, tile, x, y, w-w2, h, flip);
259 OverTileCloaked(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, flip);
260 return;
261 }
262
263 switch(flip)
264 {
265 case 1:
266 for(int32_t j=0; j<h; j++)
267 for(int32_t k=w-1; k>=0; k--)
268 overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, flip);
269
270 break;
271
272 case 2:
273 for(int32_t j=h-1; j>=0; j--)
274 for(int32_t k=0; k<w; k++)
275 overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, flip);
276
277 break;
278
279 case 3:
280 for(int32_t j=h-1; j>=0; j--)
281 for(int32_t k=w-1; k>=0; k--)
282 overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, flip);
283
284 break;
285
286 default:
287 for(int32_t j=0; j<h; j++)
288 for(int32_t k=0; k<w; k++)
289 overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, flip);
290
291 break;
292 }
293 }
294
295 static void OverTileTranslucent(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, int32_t opacity, byte skiprows=0)
296 {
297 if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
298 {
299 byte w2=(tile+w)%TILES_PER_ROW;
300 OverTileTranslucent(_Dest, tile, x, y, w-w2, h, color, flip, opacity);
301 OverTileTranslucent(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip, opacity);
302 return;
303 }
304
305 switch(flip)
306 {
307 case 1:
308 for(int32_t j=0; j<h; j++)
309 for(int32_t k=w-1; k>=0; k--)
310 overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip, opacity);
311
312 break;
313
314 case 2:
315 for(int32_t j=h-1; j>=0; j--)
316 for(int32_t k=0; k<w; k++)
317 overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip, opacity);
318
319 break;
320
321 case 3:
322 for(int32_t j=h-1; j>=0; j--)
323 for(int32_t k=w-1; k>=0; k--)
324 overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip, opacity);
325
326 break;
327
328 default:
329 for(int32_t j=0; j<h; j++)
330 for(int32_t k=0; k<w; k++)
331 overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip, opacity);
332
333 break;
334 }
335 }
336
337 static void PutTileTranslucent(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, int32_t opacity, byte skiprows=0)
338 {
339 if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
340 {
341 byte w2=(tile+w)%TILES_PER_ROW;
342 PutTileTranslucent(_Dest, tile, x, y, w-w2, h, color, flip, opacity);
343 PutTileTranslucent(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip, opacity);
344 return;
345 }
346
347 switch(flip)
348 {
349 case 1:
350 for(int32_t j=0; j<h; j++)
351 for(int32_t k=w-1; k>=0; k--)
352 puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip, opacity);
353
354 break;
355
356 case 2:
357 for(int32_t j=h-1; j>=0; j--)
358 for(int32_t k=0; k<w; k++)
359 puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip, opacity);
360
361 break;
362
363 case 3:
364 for(int32_t j=h-1; j>=0; j--)
365 for(int32_t k=w-1; k>=0; k--)
366 puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip, opacity);
367
368 break;
369
370 default:
371 for(int32_t j=0; j<h; j++)
372 for(int32_t k=0; k<w; k++)
373 puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip, opacity);
374
375 break;
376 }
377 }
378 };
379
380
381
382
383 void do_rectr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
384 {
385 //sdci[1]=layer
386 //sdci[2]=x
387 //sdci[3]=y
388 //sdci[4]=x2
389 //sdci[5]=y2
390 //sdci[6]=color
391 //sdci[7]=scale factor
392 //sdci[8]=rotation anchor x
393 //sdci[9]=rotation anchor y
394 //sdci[10]=rotation angle
395 //sdci[11]=fill
396 //sdci[12]=opacity
397 if(sdci[7]==0) //scale
398 {
399 return;
400 }
401
402 int32_t x1=sdci[2]/10000;
403 int32_t y1=sdci[3]/10000;
404 int32_t x2=sdci[4]/10000;
405 int32_t y2=sdci[5]/10000;
406
407 if(x1>x2)
408 {
409 zc_swap(x1,x2);
410 }
411
412 if(y1>y2)
413 {
414 zc_swap(y1,y2);
415 }
416
417 if(sdci[7] != 10000)
418 {
419 int32_t w=x2-x1+1;
420 int32_t h=y2-y1+1;
421 int32_t w2=(w*sdci[7])/10000;
422 int32_t h2=(h*sdci[7])/10000;
423 x1=x1-((w2-w)/2);
424 x2=x2+((w2-w)/2);
425 y1=y1-((h2-h)/2);
426 y2=y2+((h2-h)/2);
427 }
428
429 int32_t color=sdci[6]/10000;
430
431 if(sdci[12]/10000<=127) //translucent
432 {
433 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
434 }
435
436 if(sdci[10]==0) //no rotation
437 {
438 if(sdci[11]) //filled
439 {
440 rectfill(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
441 }
442 else //outline
443 {
444 rect(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
445 }
446 }
447 else //rotate
448 {
449 int32_t xy[16];
450 int32_t rx=sdci[8]/10000;
451 int32_t ry=sdci[9]/10000;
452 fixed ra1=itofix(sdci[10]%10000)/10000;
453 fixed ra2=itofix(sdci[10]/10000);
454 fixed ra=ra1+ra2;
455 ra = (ra/360)*256;
456
457 fixed fcosa = fixcos(ra);
458 fixed fsina = fixsin(ra);
459
460 xy[ 0]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry))); //x1
461 xy[ 1]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry))); //y1
462 xy[ 2]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y1 - ry))); //x2
463 xy[ 3]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y1 - ry))); //y1
464 xy[ 4]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry))); //x2
465 xy[ 5]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry))); //y2
466 xy[ 6]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y2 - ry))); //x1
467 xy[ 7]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y2 - ry))); //y2
468 xy[ 8]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry + 1))); //x1
469 xy[ 9]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry + 1))); //y1
470 xy[10]=xoffset+rx + fixtoi((fcosa * (x2 - rx - 1) - fsina * (y1 - ry))); //x2
471 xy[11]=yoffset+ry + fixtoi((fsina * (x2 - rx - 1) + fcosa * (y1 - ry))); //y1
472 xy[12]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry - 1))); //x2
473 xy[13]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry - 1))); //y2
474 xy[14]=xoffset+rx + fixtoi((fcosa * (x1 - rx + 1) - fsina * (y2 - ry))); //x1
475 xy[15]=yoffset+ry + fixtoi((fsina * (x1 - rx + 1) + fcosa * (y2 - ry))); //y2
476
477 if(sdci[11]) //filled
478 {
479 polygon(bmp, 4, xy, color);
480 }
481 else //outline
482 {
483 line(bmp, xy[0], xy[1], xy[10], xy[11], color);
484 line(bmp, xy[2], xy[3], xy[12], xy[13], color);
485 line(bmp, xy[4], xy[5], xy[14], xy[15], color);
486 line(bmp, xy[6], xy[7], xy[ 8], xy[ 9], color);
487 }
488 }
489
490 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
491 }
492
493 void do_framer(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
494 {
495 //sdci[1]=layer
496 //sdci[2]=x
497 //sdci[3]=y
498 //sdci[4]=tile
499 //sdci[5]=cset
500 //sdci[6]=width
501 //sdci[7]=height
502 //sdci[8]=overlay
503 //sdci[9]=opacity
504
505 int32_t x=sdci[2]/10000;
506 int32_t y=sdci[3]/10000;
507
508 int32_t tile=sdci[4]/10000;
509 int32_t cs=sdci[5]/10000;
510 int32_t w=sdci[6]/10000;
511 int32_t h=sdci[7]/10000;
512 bool overlay=sdci[8];
513 bool trans=(sdci[9]/10000<=127);
514
515 frame2x2(bmp, &QMisc, x + xoffset, y + yoffset, tile, cs, w, h, 0, overlay, trans);
516 }
517
518
519
520 void do_circler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
521 {
522 //sdci[1]=layer
523 //sdci[2]=x
524 //sdci[3]=y
525 //sdci[4]=radius
526 //sdci[5]=color
527 //sdci[6]=scale factor
528 //sdci[7]=rotation anchor x
529 //sdci[8]=rotation anchor y
530 //sdci[9]=rotation angle
531 //sdci[10]=fill
532 //sdci[11]=opacity
533 if(sdci[6]==0) //scale
534 {
535 return;
536 }
537
538 int32_t x1=sdci[2]/10000;
539 int32_t y1=sdci[3]/10000;
540 qword r=sdci[4];
541
542 if(sdci[6] != 10000)
543 {
544 r*=sdci[6];
545 r/=10000;
546 }
547
548 r/=10000;
549 int32_t color=sdci[5]/10000;
550
551 if(sdci[11]/10000<=127) //translucent
552 {
553 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
554 }
555
556 if(sdci[9]!=0&&(sdci[2]!=sdci[7]||sdci[3]!=sdci[8])) //rotation
557 {
558 int32_t xy[2];
559 int32_t rx=sdci[7]/10000;
560 int32_t ry=sdci[8]/10000;
561 fixed ra1=itofix(sdci[9]%10000)/10000;
562 fixed ra2=itofix(sdci[9]/10000);
563 fixed ra=ra1+ra2;
564 ra = (ra/360)*256;
565
566 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
567 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
568 x1=xy[0];
569 y1=xy[1];
570 }
571
572 if(sdci[10]) //filled
573 {
574 circlefill(bmp, x1+xoffset, y1+yoffset, r, color);
575 }
576 else //outline
577 {
578 circle(bmp, x1+xoffset, y1+yoffset, r, color);
579 }
580
581 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
582 }
583
584
585 void do_arcr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
586 {
587 //sdci[1]=layer
588 //sdci[2]=x
589 //sdci[3]=y
590 //sdci[4]=radius
591 //sdci[5]=start angle
592 //sdci[6]=end angle
593 //sdci[7]=color
594 //sdci[8]=scale factor
595 //sdci[9]=rotation anchor x
596 //sdci[10]=rotation anchor y
597 //sdci[11]=rotation angle
598 //sdci[12]=closed
599 //sdci[13]=fill
600 //sdci[14]=opacity
601
602 if(sdci[8]==0) //scale
603 {
604 return;
605 }
606
607 int32_t cx=sdci[2]/10000;
608 int32_t cy=sdci[3]/10000;
609 qword r=sdci[4];
610
611 if(sdci[8] != 10000)
612 {
613 r*=sdci[8];
614 r/=10000;
615 }
616
617 r/=10000;
618
619 int32_t color=sdci[7]/10000;
620
621 fixed ra1=itofix(sdci[11]%10000)/10000;
622 fixed ra2=itofix(sdci[11]/10000);
623 fixed ra=ra1+ra2;
624 ra = (ra/360)*256;
625
626
627 fixed a1=itofix(sdci[5]%10000)/10000;
628 fixed a2=itofix(sdci[5]/10000);
629 fixed sa=a1+a2;
630 sa = (sa/360)*256;
631
632 a1=itofix(sdci[6]%10000)/10000;
633 a2=itofix(sdci[6]/10000);
634 fixed ea=a1+a2;
635 ea = (ea/360)*256;
636
637 if(sdci[11]!=0) //rotation
638 {
639 int32_t rx=sdci[9]/10000;
640 int32_t ry=sdci[10]/10000;
641
642 cx=rx + fixtoi((fixcos(ra) * (cx - rx) - fixsin(ra) * (cy - ry))); //x1
643 cy=ry + fixtoi((fixsin(ra) * (cx - rx) + fixcos(ra) * (cy - ry))); //y1
644 ea-=ra;
645 sa-=ra;
646 }
647
648 int32_t fx=cx+fixtoi(fixcos(-(ea+sa)/2)*r/2);
649 int32_t fy=cy+fixtoi(fixsin(-(ea+sa)/2)*r/2);
650
651 if(sdci[12]) //closed
652 {
653 if(sdci[13]) //filled
654 {
655 clear_bitmap(prim_bmp);
656 arc(prim_bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
657 line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
658 line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
659 floodfill(prim_bmp, zc_max(0,fx)+xoffset, zc_max(0,fy)+yoffset, color);
660
661 if(sdci[14]/10000<=127) //translucent
662 {
663 draw_trans_sprite(bmp, prim_bmp, 0,0);
664 }
665 else
666 {
667 draw_sprite(bmp, prim_bmp, 0,0);
668 }
669 }
670 else
671 {
672 arc(bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
673 line(bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
674 line(bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
675 }
676 }
677 else
678 {
679 if(sdci[14]/10000<=127) //translucent
680 {
681 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
682 }
683
684 arc(bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
685 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
686 }
687 }
688
689
690 void do_ellipser(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
691 {
692 //sdci[1]=layer
693 //sdci[2]=x
694 //sdci[3]=y
695 //sdci[4]=radiusx
696 //sdci[5]=radiusy
697 //sdci[6]=color
698 //sdci[7]=scale factor
699 //sdci[8]=rotation anchor x
700 //sdci[9]=rotation anchor y
701 //sdci[10]=rotation angle
702 //sdci[11]=fill
703 //sdci[12]=opacity
704
705 if(sdci[7]==0) //scale
706 {
707 return;
708 }
709
710 int32_t x1=sdci[2]/10000;
711 int32_t y1=sdci[3]/10000;
712 int32_t radx=sdci[4]/10000;
713 radx*=sdci[7]/10000;
714 int32_t rady=sdci[5]/10000;
715 rady*=sdci[7]/10000;
716 int32_t color=sdci[6]/10000;
717 float rotation = sdci[10]/10000;
718
719 int32_t rx=sdci[8]/10000;
720 int32_t ry=sdci[9]/10000;
721 fixed ra1=itofix(sdci[10]%10000)/10000;
722 fixed ra2=itofix(sdci[10]/10000);
723 fixed ra=ra1+ra2;
724 ra = (ra/360)*256;
725
726 int32_t xy[2];
727 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
728 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
729 x1=xy[0];
730 y1=xy[1];
731
732 if(radx<1||rady<1||radx>255||rady>255) return;
733
734 BITMAP* bitty = script_drawing_commands.AquireSubBitmap(radx*2+1, rady*2+1);
735
736 if(sdci[11]) //filled
737 {
738
739 if(sdci[12]/10000<128) //translucent
740 {
741 clear_bitmap(prim_bmp);
742 ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
743 rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
744 draw_trans_sprite(bmp, prim_bmp, 0, 0);
745 }
746 else // no opacity
747 {
748 ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
749 rotate_sprite(bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
750 }
751 }
752 else //not filled
753 {
754 if(sdci[12]/10000<128) //translucent
755 {
756 clear_bitmap(prim_bmp);
757 ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
758 rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
759 draw_trans_sprite(bmp, prim_bmp, 0, 0);
760 }
761 else // no opacity
762 {
763 ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
764 rotate_sprite(bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
765 }
766 }
767
768 // Since 0 is the transparent color, the stuff above will fail if the ellipse color is also 0.
769 // Instead, it uses color 255 and replaces it afterward. That'll also screw up color 255 around
770 // the ellipse, but it shouldn't be used anyway.
771 if(color==0)
772 {
773 // This is very slow, so check the smallest possible square
774 int32_t endx=zc_min(bmp->w-1, x1+zc_max(radx, rady));
775 int32_t endy=zc_min(bmp->h-1, y1+zc_max(radx, rady));
776
777 for(int32_t y=zc_max(0, y1-zc_max(radx, rady)); y<=endy; y++)
778 for(int32_t x=zc_max(0, x1-zc_max(radx, rady)); x<=endx; x++)
779 if(getpixel(bmp, x, y)==255)
780 putpixel(bmp, x, y, 0);
781 }
782
783 script_drawing_commands.ReleaseSubBitmap(bitty);
784 }
785
786
787 void do_liner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
788 {
789 //sdci[1]=layer
790 //sdci[2]=x
791 //sdci[3]=y
792 //sdci[4]=x2
793 //sdci[5]=y2
794 //sdci[6]=color
795 //sdci[7]=scale factor
796 //sdci[8]=rotation anchor x
797 //sdci[9]=rotation anchor y
798 //sdci[10]=rotation angle
799 //sdci[11]=opacity
800 if(sdci[7]==0) //scale
801 {
802 return;
803 }
804
805 int32_t x1=sdci[2]/10000;
806 int32_t y1=sdci[3]/10000;
807 int32_t x2=sdci[4]/10000;
808 int32_t y2=sdci[5]/10000;
809
810 if(sdci[7] != 10000)
811 {
812 int32_t w=x2-x1+1;
813 int32_t h=y2-y1+1;
814 int32_t w2=int32_t(w*((double)sdci[7]/10000.0));
815 int32_t h2=int32_t(h*((double)sdci[7]/10000.0));
816 x1=x1-((w2-w)/2);
817 x2=x2+((w2-w)/2);
818 y1=y1-((h2-h)/2);
819 y2=y2+((h2-h)/2);
820 }
821
822 int32_t color=sdci[6]/10000;
823
824 if(sdci[11]/10000<=127) //translucent
825 {
826 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
827 }
828
829 if(sdci[10]!=0) //rotation
830 {
831 int32_t xy[4];
832 int32_t rx=sdci[8]/10000;
833 int32_t ry=sdci[9]/10000;
834 fixed ra1=itofix(sdci[10]%10000)/10000;
835 fixed ra2=itofix(sdci[10]/10000);
836 fixed ra=ra1+ra2;
837
838 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
839 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
840 xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
841 xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
842 x1=xy[0];
843 y1=xy[1];
844 x2=xy[2];
845 y2=xy[3];
846 }
847
848 line(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
849 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
850 }
851
852 void do_linesr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
853 {
854 //sdci[1]=layer
855 //sdci[2]=array[10] = { x, y, x2, y2, colour, scale, rx, ry, angle, opacity }
856
857 //sdci[2]=x
858 //sdci[3]=y
859 //sdci[4]=x2
860 //sdci[5]=y2
861 //sdci[6]=color
862 //sdci[7]=scale factor
863 //sdci[8]=rotation anchor x
864 //sdci[9]=rotation anchor y
865 //sdci[10]=rotation angle
866 //sdci[11]=opacity
867 //if(sdci[7]==0) //scale
868 //{
869 // return;
870 //}
871
872 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
873
874 if(!v_ptr)
875 {
876 al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
877 return;
878 }
879
880 std::vector<int32_t> &v = *v_ptr;
881
882 if(v.empty())
883 return;
884 //Z_scripterrlog("PutPixels reached line %d\n", 983);
885
886 int32_t* pos = &v[0];
887 int32_t sz = v.size();
888
889 for ( int32_t q = 0; q < sz; q+=10 )
890 {
891
892 int32_t x1 = v.at(q);
893 Z_scripterrlog("Lines( x1 ) is: %d\n", x1);
894 int32_t y1 = v.at(q+1);
895 Z_scripterrlog("Lines( x2 ) is: %d\n", y1);
896 int32_t x2 = v.at(q+2);
897 Z_scripterrlog("Lines( x2 ) is: %d\n", x2);
898 int32_t y2 = v.at(q+3);
899 Z_scripterrlog("Lines( y2 ) is: %d\n", y2);
900 int32_t color = v.at(q+4);
901 Z_scripterrlog("Lines( colour ) is: %d\n", color);
902 Z_scripterrlog("Lines( scale ) is: %d\n", v.at(q+5));
903 if (v.at(q+5) == 0) { Z_scripterrlog("Lines() aborting due to scale\n"); return; }//scale
904
905 if( v.at(q+5) != 10000)
906 {
907 int32_t w=x2-x1+1;
908 int32_t h=y2-y1+1;
909 int32_t w2=int32_t(w*((double)v.at(q+5)));
910 int32_t h2=int32_t(h*((double)v.at(q+5)));
911 x1=x1-((w2-w)/2);
912 x2=x2+((w2-w)/2);
913 y1=y1-((h2-h)/2);
914 y2=y2+((h2-h)/2);
915 }
916
917
918 Z_scripterrlog("Lines( opacity ) is: %d\n", v.at(q+9));
919 if(v.at(q+9) <= 127) //translucent
920 {
921 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
922 }
923 else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
924 Z_scripterrlog("Lines( rotation ) is: %d\n", v.at(q+8));
925 Z_scripterrlog("Lines( rot_x ) is: %d\n", v.at(q+6));
926 Z_scripterrlog("Lines( rot_x ) is: %d\n", v.at(q+7));
927 if( v.at(q+8) !=0 ) //rotation
928 {
929 int32_t xy[4];
930
931 int32_t rx = v.at(q+6);
932
933 int32_t ry = v.at(q+7);
934
935 fixed ra1=itofix(v.at(q+8) % 1);
936 fixed ra2=itofix(v.at(q+8));
937 fixed ra=ra1+ra2;
938
939 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
940 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
941 xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
942 xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
943 x1=xy[0];
944 y1=xy[1];
945 x2=xy[2];
946 y2=xy[3];
947 }
948 Z_scripterrlog("Lines( xofs ) is: %d\n", xoffset);
949 Z_scripterrlog("Lines( yofs ) is: %d\n", yoffset);
950 line(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
951 }
952 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
953 }
954
955 void do_polygonr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
956 {
957 //sdci[1]=layer
958 //sdci[2]=point count
959 //sdci[3]array[]
960 //sdci[4] = colour
961 //sdci[5] = opacity
962
963 int32_t col = sdci[4]/10000;
964 int32_t op = sdci[5]/10000;
965
966 //bool brokenOffset= ( (get_bit(extra_rules, er_BITMAPOFFSET)!=0) || (get_bit(quest_rules,qr_BITMAPOFFSETFIX)!=0) );
967 //Z_scripterrlog("Broken offset rule for Polygon() is: %s\n", brokenOffset ? "ON" : "OFF");
968 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
969
970 if(!v_ptr)
971 {
972 al_trace("Screen->Polygon: Vector pointer is null! Internal error. \n");
973 return;
974 }
975
976 std::vector<int32_t> &v = *v_ptr;
977
978 if(v.empty())
979 return;
980 //Z_scripterrlog("PutPixels reached line %d\n", 983);
981
982 int32_t* pos = &v[0];
983 int32_t sz = v.size();
984 int32_t numpoints = (sdci[2]/10000);
985 if(sz & 1) --sz; //even amount only
986 if(numpoints > sz/2) //cap to array
987 numpoints = sz/2;
988 if(numpoints < 1)
989 return; //Don't draw 0 or negative point count
990
991 //Fix the draw Y offset. -Z 20th June, 2019
992 for ( int32_t q = 1; q < sz; q+=2 )
993 {
994 pos[q] += yoffset;
995 }
996 if(op <= 127) //translucent
997 {
998 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
999 }
1000 else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1001
1002 polygon(bmp, numpoints, (int32_t*)pos, col);
1003 //polygon(bmp, (sdci[2]/10000), &v, col);
1004 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1005 }
1006
1007 void bmp_do_polygonr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1008 {
1009 //sdci[1]=layer
1010 //sdci[2]=point count
1011 //sdci[3]array[]
1012 //sdci[4] = colour
1013 //sdci[5] = opacity
1014
1015 int32_t col = sdci[4]/10000;
1016 int32_t op = sdci[5]/10000;
1017
1018 if ( sdci[17] <= 0 )
1019 {
1020 Z_scripterrlog("bitmap->Rectangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
1021 return;
1022 }
1023 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
1024 if ( refbmp == NULL ) return;
1025
1026 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
1027
1028 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1029
1030 if(!v_ptr)
1031 {
1032 al_trace("Screen->Polygon: Vector pointer is null! Internal error. \n");
1033 return;
1034 }
1035
1036 std::vector<int32_t> &v = *v_ptr;
1037
1038 if(v.empty())
1039 return;
1040 //Z_scripterrlog("PutPixels reached line %d\n", 983);
1041
1042 int32_t* pos = &v[0];
1043 int32_t sz = v.size();
1044 int32_t numpoints = (sdci[2]/10000);
1045 if(sz & 1) --sz; //even amount only
1046 if(numpoints > sz/2) //cap to array
1047 numpoints = sz/2;
1048 if(numpoints < 1)
1049 return; //Don't draw 0 or negative point count
1050
1051 //Fix the draw Y offset. -Z 20th June, 2019
1052 for ( int32_t q = 1; q < sz; q+=2 )
1053 {
1054 pos[q] += yoffset;
1055 }
1056 if(op <= 127) //translucent
1057 {
1058 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1059 }
1060 else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1061
1062 polygon(refbmp, numpoints, (int32_t*)pos, col);
1063 //polygon(refbmp, (sdci[2]/10000), &v, col);
1064 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1065 }
1066
1067 void do_spliner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1068 {
1069 /* layer, x1, y1, x2, y2, x3, y3, x4, y4, color, opacity */
1070
1071 int32_t points[8] = { xoffset + (sdci[2]/10000), yoffset + (sdci[3]/10000),
1072 xoffset + (sdci[4]/10000), yoffset + (sdci[5]/10000),
1073 xoffset + (sdci[6]/10000), yoffset + (sdci[7]/10000),
1074 xoffset + (sdci[8]/10000), yoffset + (sdci[9]/10000)
1075 };
1076
1077 if(sdci[11]/10000 < 128) //translucent
1078 {
1079 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1080 }
1081
1082 spline(bmp, points, sdci[10]/10000);
1083
1084 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1085 }
1086
1087
1088 void do_putpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1089 {
1090 //sdci[1]=layer
1091 //sdci[2]=x
1092 //sdci[3]=y
1093 //sdci[4]=color
1094 //sdci[5]=rotation anchor x
1095 //sdci[6]=rotation anchor y
1096 //sdci[7]=rotation angle
1097 //sdci[8]=opacity
1098 int32_t x1=sdci[2]/10000;
1099 int32_t y1=sdci[3]/10000;
1100 int32_t color=sdci[4]/10000;
1101
1102 if(sdci[8]/10000<=127) //translucent
1103 {
1104 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1105 }
1106
1107 if(sdci[7]!=0) //rotation
1108 {
1109 int32_t xy[2];
1110 int32_t rx=sdci[5]/10000;
1111 int32_t ry=sdci[6]/10000;
1112 fixed ra1=itofix(sdci[7]%10000)/10000;
1113 fixed ra2=itofix(sdci[7]/10000);
1114 fixed ra=ra1+ra2;
1115
1116 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1117 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1118 x1=xy[0];
1119 y1=xy[1];
1120 }
1121
1122 putpixel(bmp, x1+xoffset, y1+yoffset, color);
1123 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1124 }
1125
1126 void do_putpixelsr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1127 {
1128 //Z_scripterrlog("Starting putpixels()%s\n");
1129 //sdci[1]=layer
1130 //sdci[2]=array {x,y,colour,opacity}
1131 //sdci[3]=rotation anchor x
1132 //sdci[4]=rotation anchor y
1133 //sdci[5]=rotation angle
1134
1135
1136 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1137
1138 if(!v_ptr)
1139 {
1140 al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
1141 return;
1142 }
1143
1144 std::vector<int32_t> &v = *v_ptr;
1145
1146 if(v.empty())
1147 return;
1148 //Z_scripterrlog("PutPixels reached line %d\n", 983);
1149
1150 int32_t* pos = &v[0];
1151 int32_t sz = v.size();
1152 //Z_scripterrlog("Vector size is: %d\n", sz);
1153 //for ( int32_t m = 0; m < 256; ++m ) Z_scripterrlog("Vector contents at pos[%d]: %d\n", m, pos[m]);
1154
1155 //FFCore.getValues(sdci[2]/10000, points, sz);
1156
1157
1158 int32_t x1 = 0;
1159 int32_t y1 = 0;
1160
1161 for ( int32_t q = 0; q < sz; q+=4 )
1162 {
1163 //Z_scripterrlog("Vector q: %d\n", q);
1164 //if ( q > sz-1 ) break;
1165 x1 = v.at(q); //pos[q];
1166 y1 = v.at(q+1); //pos[q+1];
1167 //Z_scripterrlog("x1 is: %d\n", x1);
1168 //Z_scripterrlog("y1 is: %d\n", 1);
1169 if(sdci[5]!=0) //rotation
1170 {
1171 int32_t xy[2];
1172 int32_t rx=sdci[3]/10000;
1173 int32_t ry=sdci[4]/10000;
1174 fixed ra1=itofix(sdci[5]%10000)/10000;
1175 fixed ra2=itofix(sdci[5]/10000);
1176 fixed ra=ra1+ra2;
1177
1178 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1179 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1180 x1=xy[0];
1181 y1=xy[1];
1182 }
1183 //Z_scripterrlog("PutPixels()%s value is %d\n","x",x1);
1184 //Z_scripterrlog("PutPixels()%s value is %d\n","y",y1);
1185 //Z_scripterrlog("PutPixels()%s value is %d\n","colour",points[q+2]);
1186 if ( v.at(q+3) /*pos[q+3]*/ < 128 ) drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1187 else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1188 putpixel(bmp, x1+xoffset, y1+yoffset, v.at(q+2) /*pos[q+2]*/);
1189 //if ( points[q+3] < 128 )
1190
1191 //else drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1192 }
1193 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1194 }
1195
1196 void do_drawtiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1197 {
1198 //sdci[1]=layer
1199 //sdci[2]=x
1200 //sdci[3]=y
1201 //sdci[4]=tile
1202 //sdci[5]=tile width
1203 //sdci[6]=tile height
1204 //sdci[7]=color (cset)
1205 //sdci[8]=scale x
1206 //sdci[9]=scale y
1207 //sdci[10]=rotation anchor x
1208 //sdci[11]=rotation anchor y
1209 //sdci[12]=rotation angle
1210 //sdci[13]=flip
1211 //sdci[14]=transparency
1212 //sdci[15]=opacity
1213
1214 int32_t w = sdci[5]/10000;
1215 int32_t h = sdci[6]/10000;
1216
1217 if(w < 1 || h < 1 || h > 20 || w > 20)
1218 {
1219 return;
1220 }
1221
1222 int32_t xscale=sdci[8]/10000;
1223 int32_t yscale=sdci[9]/10000;
1224 int32_t rx = sdci[10]/10000;
1225 int32_t ry = sdci[11]/10000;
1226 float rotation=sdci[12]/10000;
1227 int32_t flip=(sdci[13]/10000)&3;
1228 bool transparency=sdci[14]!=0;
1229 int32_t opacity=sdci[15]/10000;
1230 int32_t color=sdci[7]/10000;
1231
1232 int32_t x1=sdci[2]/10000;
1233 int32_t y1=sdci[3]/10000;
1234
1235 //don't scale if it's not safe to do so
1236 bool canscale = true;
1237
1238 if(xscale==0||yscale==0)
1239 {
1240 return;
1241 }
1242
1243 if(xscale<0||yscale<0)
1244 canscale = false; //default size
1245
1246 if((xscale>0 && yscale>0) || rotation) //scaled or rotated
1247 {
1248 BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16);
1249
1250 if(transparency) //transparency
1251 {
1252 TileHelper::OverTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
1253 }
1254 else //no transparency
1255 {
1256 TileHelper::OldPutTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
1257 }
1258
1259 if(rotation != 0)
1260 {
1261 //low negative values indicate no anchor-point rotation
1262 if(rx>-777||ry>-777)
1263 {
1264 int32_t xy[2];
1265 fixed ra1=itofix(sdci[12]%10000)/10000;
1266 fixed ra2=itofix(sdci[12]/10000);
1267 fixed ra=ra1+ra2;
1268 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1269 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1270 x1=xy[0];
1271 y1=xy[1];
1272 }
1273
1274 if(canscale) //scale first
1275 {
1276 //damnit all, .. fixme.
1277 BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
1278 clear_bitmap(tempbit);
1279
1280 stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
1281
1282 if(opacity < 128)
1283 {
1284 clear_bitmap(prim_bmp);
1285 rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
1286 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1287 }
1288 else
1289 {
1290 rotate_sprite(bmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1291 }
1292
1293 destroy_bitmap(tempbit);
1294 }
1295 else //no scale
1296 {
1297 if(opacity < 128)
1298 {
1299 clear_bitmap(prim_bmp);
1300 rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
1301 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1302 }
1303 else
1304 {
1305 rotate_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1306 }
1307 }
1308 }
1309 else //scale only
1310 {
1311 if(canscale)
1312 {
1313 if(opacity<128)
1314 {
1315 clear_bitmap(prim_bmp);
1316 stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
1317 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1318 }
1319 else
1320 {
1321 stretch_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
1322 }
1323 }
1324 else //error -do not scale
1325 {
1326 if(opacity<128)
1327 {
1328 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1329 }
1330 else
1331 {
1332 draw_sprite(bmp, pbitty, x1+xoffset, y1+yoffset);
1333 }
1334 }
1335 }
1336
1337 script_drawing_commands.ReleaseSubBitmap(pbitty);
1338
1339 }
1340 else // no scale or rotation
1341 {
1342 if(transparency)
1343 {
1344 if(opacity<=127)
1345 TileHelper::OverTileTranslucent(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
1346 else
1347 TileHelper::OverTile(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
1348 }
1349 else
1350 {
1351 if(opacity<=127)
1352 TileHelper::PutTileTranslucent(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
1353 else
1354 TileHelper::OldPutTile(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
1355 }
1356 }
1357 }
1358
1359 void do_drawtilecloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1360 {
1361 //sdci[1]=layer
1362 //sdci[2]=x
1363 //sdci[3]=y
1364 //sdci[4]=tile
1365 //sdci[5]=tile width
1366 //sdci[6]=tile height
1367 //sdci[7]=flip
1368
1369 int32_t w = sdci[5]/10000;
1370 int32_t h = sdci[6]/10000;
1371
1372 if(w < 1 || h < 1 || h > 20 || w > 20)
1373 {
1374 return;
1375 }
1376
1377 int32_t flip=(sdci[7]/10000)&3;
1378
1379 int32_t x1=sdci[2]/10000;
1380 int32_t y1=sdci[3]/10000;
1381
1382 TileHelper::OverTileCloaked(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, flip);
1383 }
1384
1385
1386 void do_drawcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1387 {
1388 //sdci[1]=layer
1389 //sdci[2]=x
1390 //sdci[3]=y
1391 //sdci[4]=combo
1392 //sdci[5]=tile width
1393 //sdci[6]=tile height
1394 //sdci[7]=color (cset)
1395 //sdci[8]=scale x
1396 //sdci[9]=scale y
1397 //sdci[10]=rotation anchor x
1398 //sdci[11]=rotation anchor y
1399 //sdci[12]=rotation angle
1400 //sdci[13]=frame
1401 //sdci[14]=flip
1402 //sdci[15]=transparency
1403 //sdci[16]=opacity
1404
1405 int32_t w = sdci[5]/10000;
1406 int32_t h = sdci[6]/10000;
1407
1408 if(w<1||h<1||h>20||w>20)
1409 {
1410 return;
1411 }
1412 int32_t cmb = (sdci[4]/10000);
1413 if((unsigned)cmb >= MAXCOMBOS)
1414 {
1415 Z_scripterrlog("DrawCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1416 return;
1417 }
1418
1419 int32_t xscale=sdci[8]/10000;
1420 int32_t yscale=sdci[9]/10000;
1421 int32_t rx = sdci[10]/10000; //these work now
1422 int32_t ry = sdci[11]/10000; //these work now
1423 float rotation=sdci[12]/10000;
1424
1425 bool transparency=sdci[15]!=0;
1426 int32_t opacity=sdci[16]/10000;
1427 int32_t color=sdci[7]/10000;
1428 int32_t x1=sdci[2]/10000;
1429 int32_t y1=sdci[3]/10000;
1430
1431 const newcombo & c = combobuf[cmb];
1432 int32_t tiletodraw = combo_tile(c, x1, y1);
1433 int32_t flip = ((sdci[14]/10000) & 3) ^ c.flip;
1434 int32_t skiprows=c.skipanimy;
1435
1436
1437 //don't scale if it's not safe to do so
1438 bool canscale = true;
1439
1440 if(xscale==0||yscale==0)
1441 {
1442 return;
1443 }
1444
1445 if(xscale<0||yscale<0)
1446 canscale = false; //default size
1447
1448 if((xscale>0 && yscale>0) || rotation) //scaled or rotated
1449 {
1450 BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16); //-pbitty in the hisouse. :D
1451
1452 if(transparency)
1453 {
1454 TileHelper::OverTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
1455 }
1456 else //no transparency
1457 {
1458 TileHelper::OldPutTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
1459 }
1460
1461 if(rotation != 0) // rotate
1462 {
1463 //fixed point sucks ;0
1464 if(rx>-777||ry>-777) //set the rotation anchor and rotate around that
1465 {
1466 int32_t xy[2];
1467 fixed ra1=itofix(sdci[12]%10000)/10000;
1468 fixed ra2=itofix(sdci[12]/10000);
1469 fixed ra=ra1+ra2;
1470 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1471 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1472 x1=xy[0];
1473 y1=xy[1];
1474 }
1475
1476 if(canscale) //scale first
1477 {
1478 BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
1479 clear_bitmap(tempbit);
1480
1481 stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
1482
1483 if(opacity < 128)
1484 {
1485 clear_bitmap(prim_bmp);
1486 rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
1487 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1488 }
1489 else
1490 {
1491 rotate_sprite(bmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1492 }
1493
1494 destroy_bitmap(tempbit);
1495 }
1496 else //no scale
1497 {
1498 if(opacity < 128)
1499 {
1500 clear_bitmap(prim_bmp);
1501 rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
1502 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1503 }
1504 else
1505 {
1506 rotate_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1507 }
1508 }
1509 }
1510 else //scale only
1511 {
1512 if(canscale)
1513 {
1514 if(opacity<128)
1515 {
1516 clear_bitmap(prim_bmp);
1517 stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
1518 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1519 }
1520 else
1521 {
1522 stretch_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
1523 }
1524 }
1525 else //error -do not scale
1526 {
1527 if(opacity<128)
1528 {
1529 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1530 }
1531 else
1532 {
1533 draw_sprite(bmp, pbitty, x1+xoffset, y1+yoffset);
1534 }
1535 }
1536 }
1537
1538 script_drawing_commands.ReleaseSubBitmap(pbitty); //rap sucks
1539 }
1540 else // no scale or rotation
1541 {
1542 if(transparency)
1543 {
1544 if(opacity<=127)
1545 TileHelper::OverTileTranslucent(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
1546 else
1547 TileHelper::OverTile(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
1548 }
1549 else
1550 {
1551 if(opacity<=127)
1552 TileHelper::PutTileTranslucent(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
1553 else
1554 TileHelper::OldPutTile(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
1555 }
1556 }
1557 }
1558
1559 void do_drawcombocloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1560 {
1561 //sdci[1]=layer
1562 //sdci[2]=x
1563 //sdci[3]=y
1564 //sdci[4]=combo
1565 //sdci[5]=tile width
1566 //sdci[6]=tile height
1567 //sdci[7]=flip
1568
1569 int32_t w = sdci[5]/10000;
1570 int32_t h = sdci[6]/10000;
1571
1572 if(w<1||h<1||h>20||w>20)
1573 {
1574 return;
1575 }
1576 int32_t cmb = (sdci[4]/10000);
1577 if((unsigned)cmb >= MAXCOMBOS)
1578 {
1579 Z_scripterrlog("DrawComboCloaked() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1580 return;
1581 }
1582
1583 int32_t x1=sdci[2]/10000;
1584 int32_t y1=sdci[3]/10000;
1585
1586 const newcombo & c = combobuf[cmb];
1587 int32_t tiletodraw = combo_tile(c, x1, y1);
1588 int32_t flip = ((sdci[7]/10000) & 3) ^ c.flip;
1589 int32_t skiprows=c.skipanimy;
1590
1591 TileHelper::OverTileCloaked(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, flip, skiprows);
1592 }
1593
1594
1595 void do_fasttiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1596 {
1597 /* layer, x, y, tile, color opacity */
1598
1599 int32_t opacity = sdci[6]/10000;
1600
1601 if(opacity < 128)
1602 overtiletranslucent16(bmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0, opacity);
1603 else
1604 overtile16(bmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0);
1605 }
1606
1607 void do_fasttilesr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1608 {
1609 /* layer, x, y, tile, color opacity */
1610
1611 //sdci[1]=layer
1612 //sdci[2]=array {x,y,tile,colour,opacity}
1613
1614 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1615
1616 if(!v_ptr)
1617 {
1618 al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
1619 return;
1620 }
1621
1622 std::vector<int32_t> &v = *v_ptr;
1623
1624 if(v.empty())
1625 return;
1626 //Z_scripterrlog("PutPixels reached line %d\n", 983);
1627
1628 int32_t* pos = &v[0];
1629 int32_t sz = v.size();
1630
1631 for ( int32_t q = 0; q < sz; q+=5 )
1632 {
1633
1634 if(v.at(q+4) < 128)
1635 overtiletranslucent16(bmp, v.at(q), xoffset+(v.at(q+1)), yoffset+(v.at(q+2)), v.at(q+3), 0, v.at(q+4));
1636 else
1637 overtile16(bmp, v.at(q), xoffset+(v.at(q+1)), yoffset+(v.at(q+2)), v.at(q+3), 0);
1638 }
1639 }
1640
1641
1642
1643 void do_fastcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1644 {
1645 /* layer, x, y, tile, color opacity */
1646
1647 int32_t opacity = sdci[6] / 10000;
1648 int32_t x1 = sdci[2] / 10000;
1649 int32_t y1 = sdci[3] / 10000;
1650
1651 int32_t cmb = (sdci[4]/10000);
1652 if((unsigned)cmb >= MAXCOMBOS)
1653 {
1654 Z_scripterrlog("FastCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1655 return;
1656 }
1657 //if( index >= MAXCOMBOS ) return; //bleh.
1658 /*
1659 const newcombo & c = combobuf[index];
1660
1661 if(opacity < 128)
1662 overtiletranslucent16(bmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip, opacity);
1663 else
1664 overtile16(bmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip);
1665 */
1666
1667 if(opacity < 128)
1668 {
1669 //void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
1670 overcomboblocktranslucent(bmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1, 128);
1671
1672 }
1673 else
1674 {
1675 //overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
1676 overcomboblock(bmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1);
1677 }
1678 }
1679
1680 void do_fastcombosr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1681 {
1682 /* layer, x, y, combo, cset, opacity */
1683
1684 //sdci[1]=layer
1685 //sdci[2]=array {x,y,combo,cset,opacity}
1686
1687 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1688
1689 if(!v_ptr)
1690 {
1691 al_trace("Screen->FastCombos: Vector pointer is null! Internal error. \n");
1692 return;
1693 }
1694
1695 std::vector<int32_t> &v = *v_ptr;
1696
1697 if(v.empty())
1698 return;
1699
1700 int32_t* pos = &v[0];
1701 int32_t sz = v.size();
1702
1703 for ( int32_t q = 0; q < sz; q+=5 )
1704 {
1705 if((unsigned)(v.at(q+2)) >= MAXCOMBOS)
1706 {
1707 Z_scripterrlog("FastCombos() cannot draw combo '%d', as it is out of bounds.\n", v.at(q+2));
1708 continue;
1709 }
1710 if(v.at(q+4) < 128)
1711 {
1712 //void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
1713 overcomboblocktranslucent(bmp, xoffset+v.at(q), yoffset+v.at(q+1), v.at(q+2), v.at(q+3), 1, 1, 128);
1714
1715 }
1716 else
1717 {
1718 //overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
1719 overcomboblock(bmp, xoffset+v.at(q), yoffset+v.at(q+1), v.at(q+2), v.at(q+3), 1, 1);
1720 }
1721 }
1722 }
1723
1724
1725
1726
1727 void do_drawcharr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1728 {
1729 //broken 2.50.2 and earlier drawcharacter()
1730 if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
1731 {
1732 //sdci[1]=layer
1733 //sdci[2]=x
1734 //sdci[3]=y
1735 //sdci[4]=font
1736 //sdci[5]=color
1737 //sdci[6]=bg color
1738 //sdci[7]=strech x (width)
1739 //sdci[8]=stretch y (height)
1740 //sdci[9]=char
1741 //sdci[10]=opacity
1742
1743 int32_t x=sdci[2]/10000;
1744 int32_t y=sdci[3]/10000;
1745 int32_t font_index=sdci[4]/10000;
1746 int32_t color=sdci[5]/10000;
1747 int32_t bg_color=sdci[6]/10000; //-1 = transparent
1748 int32_t w=sdci[7]/10000;
1749 int32_t h=sdci[8]/10000;
1750 char glyph=char(sdci[9]/10000);
1751 int32_t opacity=sdci[10]/10000;
1752
1753 //safe check
1754 if(bg_color < -1) bg_color = -1;
1755
1756 if(w>512) w=512; //w=vbound(w,0,512);
1757
1758 if(h>512) h=512; //h=vbound(h,0,512);
1759
1760 //undone
1761 if(w>0&&h>0)//stretch the character
1762 {
1763 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1764
1765 if(opacity < 128)
1766 {
1767 if(w>128||h>128)
1768 {
1769 clear_bitmap(prim_bmp);
1770
1771 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1772 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1773 draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1774 }
1775 else //this is faster
1776 {
1777 BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
1778
1779 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1780 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1781 draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1782
1783 script_drawing_commands.ReleaseSubBitmap(pbmp2);
1784 }
1785 }
1786 else // no opacity
1787 {
1788 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1789 stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1790 }
1791
1792 }
1793 else //no stretch
1794 {
1795 if(opacity < 128)
1796 {
1797 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
1798 clear_bitmap(pbmp);
1799
1800 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1801 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
1802
1803 destroy_bitmap(pbmp);
1804 }
1805 else // no opacity
1806 {
1807 textprintf_ex(bmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
1808 }
1809 }
1810 }
1811
1812 else //2.53.0 fixed version and later.
1813 {
1814
1815 //sdci[1]=layer
1816 //sdci[2]=x
1817 //sdci[3]=y
1818 //sdci[4]=font
1819 //sdci[5]=color
1820 //sdci[6]=bg color
1821 //sdci[7]=strech x (width)
1822 //sdci[8]=stretch y (height)
1823 //sdci[9]=char
1824 //sdci[10]=opacity
1825
1826 int32_t x=sdci[2]/10000;
1827 int32_t y=sdci[3]/10000;
1828 int32_t font_index=sdci[4]/10000;
1829 int32_t color=sdci[5]/10000;
1830 int32_t bg_color=sdci[6]/10000; //-1 = transparent
1831 int32_t w=sdci[7]/10000;
1832 int32_t h=sdci[8]/10000;
1833 char glyph=char(sdci[9]/10000);
1834 int32_t opacity=sdci[10]/10000;
1835
1836 //safe check
1837 if(bg_color < -1) bg_color = -1;
1838
1839 if(w>512) w=512; //w=vbound(w,0,512);
1840
1841 if(h>512) h=512; //h=vbound(h,0,512);
1842
1843 //undone
1844 if(w>0&&h>0)//stretch the character
1845 {
1846 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1847
1848 if(opacity < 128)
1849 {
1850 if(w>128||h>128)
1851 {
1852 clear_bitmap(prim_bmp);
1853
1854 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1855 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1856 draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1857 }
1858 else //this is faster
1859 {
1860 BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
1861
1862 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1863 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1864 draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1865
1866 script_drawing_commands.ReleaseSubBitmap(pbmp2);
1867 }
1868 }
1869 else // no opacity
1870 {
1871 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1872 stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1873 }
1874
1875 }
1876 else //no stretch
1877 {
1878 if(opacity < 128)
1879 {
1880 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
1881 clear_bitmap(pbmp);
1882
1883 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1884 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
1885
1886 destroy_bitmap(pbmp);
1887 }
1888 else // no opacity
1889 {
1890 textprintf_ex(bmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
1891 }
1892 }
1893
1894 }
1895
1896 }
1897
1898
1899 void do_drawintr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1900 {
1901 //broken 2.50.2 and earlier drawinteger()
1902 if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
1903 {
1904 //sdci[1]=layer
1905 //sdci[2]=x
1906 //sdci[3]=y
1907 //sdci[4]=font
1908 //sdci[5]=color
1909 //sdci[6]=bg color
1910 //sdci[7]=strech x (width)
1911 //sdci[8]=stretch y (height)
1912 //sdci[9]=integer
1913 //sdci[10]=num decimal places
1914 //sdci[11]=opacity
1915
1916 int32_t x=sdci[2]/10000;
1917 int32_t y=sdci[3]/10000;
1918 int32_t font_index=sdci[4]/10000;
1919 int32_t color=sdci[5]/10000;
1920 int32_t bg_color=sdci[6]/10000; //-1 = transparent
1921 int32_t w=sdci[7]/10000;
1922 int32_t h=sdci[8]/10000;
1923 //float number=static_cast<float>(sdci[9])/10000.0f;
1924 int32_t decplace=sdci[10]/10000;
1925 int32_t opacity=sdci[11]/10000;
1926
1927 //safe check
1928 if(bg_color < -1) bg_color = -1;
1929
1930 if(w>512) w=512; //w=vbound(w,0,512);
1931
1932 if(h>512) h=512; //h=vbound(h,0,512);
1933
1934 char numbuf[15];
1935
1936 switch(decplace)
1937 {
1938 default:
1939 case 0:
1940 sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
1941 break; //reducing the value by -1, so 8.000 printed as '7'. -Z
1942
1943 case 1:
1944 //sprintf(numbuf,"%.01f",number);
1945 sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
1946 break;
1947
1948 case 2:
1949 //sprintf(numbuf,"%.02f",number);
1950 sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
1951 break;
1952
1953 case 3:
1954 //sprintf(numbuf,"%.03f",number);
1955 sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
1956 break;
1957
1958 case 4:
1959 //sprintf(numbuf,"%.04f",number);
1960 sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
1961 break;
1962 }
1963
1964 if(w>0&&h>0)//stretch
1965 {
1966 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1967
1968 if(opacity < 128)
1969 {
1970 if(w>128||h>128)
1971 {
1972 clear_bitmap(prim_bmp);
1973
1974 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1975 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1976 draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1977 }
1978 else
1979 {
1980 BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
1981 clear_bitmap(pbmp2);
1982
1983 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1984 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1985 draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1986
1987 destroy_bitmap(pbmp2);
1988 }
1989 }
1990 else // no opacity
1991 {
1992 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1993 stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1994 }
1995
1996 }
1997 else //no stretch
1998 {
1999 if(opacity < 128)
2000 {
2001 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
2002 clear_bitmap(pbmp);
2003
2004 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2005 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2006
2007 destroy_bitmap(pbmp);
2008 }
2009 else // no opacity
2010 {
2011 textout_ex(bmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
2012 }
2013 }
2014
2015 }
2016
2017 else //2.53.0 fixed version and later.
2018 {
2019 //sdci[1]=layer
2020 //sdci[2]=x
2021 //sdci[3]=y
2022 //sdci[4]=font
2023 //sdci[5]=color
2024 //sdci[6]=bg color
2025 //sdci[7]=strech x (width)
2026 //sdci[8]=stretch y (height)
2027 //sdci[9]=integer
2028 //sdci[10]=num decimal places
2029 //sdci[11]=opacity
2030
2031 int32_t x=sdci[2]/10000;
2032 int32_t y=sdci[3]/10000;
2033 int32_t font_index=sdci[4]/10000;
2034 int32_t color=sdci[5]/10000;
2035 int32_t bg_color=sdci[6]/10000; //-1 = transparent
2036 int32_t w=sdci[7]/10000;
2037 int32_t h=sdci[8]/10000;
2038 //float number=static_cast<float>(sdci[9])/10000.0f;
2039 //int32_t numberint = sdci[9]/10000;
2040 int32_t decplace=sdci[10]/10000;
2041 int32_t opacity=sdci[11]/10000;
2042
2043 //safe check
2044 if(bg_color < -1) bg_color = -1;
2045
2046 if(w>512) w=512; //w=vbound(w,0,512);
2047
2048 if(h>512) h=512; //h=vbound(h,0,512);
2049
2050 char numbuf[15];
2051
2052 switch(decplace)
2053 {
2054 default:
2055 case 0:
2056 sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
2057 break; //reducing the value by -1, so 8.000 printed as '7'. -Z
2058
2059 case 1:
2060 //sprintf(numbuf,"%.01f",number);
2061 sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
2062 break;
2063
2064 case 2:
2065 //sprintf(numbuf,"%.02f",number);
2066 sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
2067 break;
2068
2069 case 3:
2070 //sprintf(numbuf,"%.03f",number);
2071 sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
2072 break;
2073
2074 case 4:
2075 //sprintf(numbuf,"%.04f",number);
2076 sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
2077 break;
2078 }
2079
2080 //FONT* font=get_zc_font(sdci[4]/10000);
2081
2082 if(w>0&&h>0)//stretch
2083 {
2084 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(get_zc_font(font_index), numbuf)+1, text_height(get_zc_font(font_index)));
2085 clear_bitmap(pbmp);
2086 //script_drawing_commands.GetSmallTextureBitmap(1,1);
2087
2088 if(opacity < 128)
2089 {
2090 if(w>128||h>128)
2091 {
2092 clear_bitmap(prim_bmp);
2093
2094 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2095 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
2096 draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
2097 }
2098 else
2099 {
2100 BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
2101 clear_bitmap(pbmp2);
2102
2103 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2104 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
2105 draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
2106
2107 destroy_bitmap(pbmp2);
2108 }
2109 }
2110 else // no opacity
2111 {
2112 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2113 stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
2114 }
2115
2116 }
2117 else //no stretch
2118 {
2119 if(opacity < 128)
2120 {
2121 FONT* font = get_zc_font(font_index);
2122 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(font, numbuf), text_height(font));
2123 clear_bitmap(pbmp);
2124
2125 textout_ex(pbmp, font, numbuf, 0, 0, color, bg_color);
2126 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2127
2128 destroy_bitmap(pbmp);
2129 }
2130 else // no opacity
2131 {
2132 textout_ex(bmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
2133 }
2134 }
2135 }
2136 }
2137
2138
2139 void do_drawstringr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2140 {
2141 //sdci[1]=layer
2142 //sdci[2]=x
2143 //sdci[3]=y
2144 //sdci[4]=font
2145 //sdci[5]=color
2146 //sdci[6]=bg color
2147 //sdci[7]=format_option
2148 //sdci[8]=string
2149 //sdci[9]=opacity
2150
2151 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
2152
2153 if(!str)
2154 {
2155 al_trace("String pointer is null! Internal error. \n");
2156 return;
2157 }
2158
2159 int32_t x=sdci[2]/10000;
2160 int32_t y=sdci[3]/10000;
2161 FONT* font=get_zc_font(sdci[4]/10000);
2162 int32_t color=sdci[5]/10000;
2163 int32_t bg_color=sdci[6]/10000; //-1 = transparent
2164 int32_t format_type=sdci[7]/10000;
2165 int32_t opacity=sdci[9]/10000;
2166 //sdci[8] not needed :)
2167
2168 //safe check
2169 if(bg_color < -1) bg_color = -1;
2170
2171 if(opacity < 128)
2172 {
2173 int32_t width=zc_min(text_length(font, str->c_str()), 512);
2174 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
2175 clear_bitmap(pbmp);
2176 textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
2177 if(format_type == 2) // right-sided text
2178 x-=width;
2179 else if(format_type == 1) // centered text
2180 x-=width/2;
2181 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2182 destroy_bitmap(pbmp);
2183 }
2184 else // no opacity
2185 {
2186 if(format_type == 2) // right-sided text
2187 {
2188 textout_right_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2189 }
2190 else if(format_type == 1) // centered text
2191 {
2192 textout_centre_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2193 }
2194 else // standard left-sided text
2195 {
2196 textout_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2197 }
2198 }
2199 }
2200
2201 void do_drawstringr2(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2202 {
2203 //sdci[1]=layer
2204 //sdci[2]=x
2205 //sdci[3]=y
2206 //sdci[4]=font
2207 //sdci[5]=color
2208 //sdci[6]=bg color
2209 //sdci[7]=format_option
2210 //sdci[8]=string
2211 //sdci[9]=opacity
2212 //sdci[10]=shadowtype
2213 //sdci[11]=shadow_color
2214
2215 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
2216
2217 if(!str)
2218 {
2219 al_trace("String pointer is null! Internal error. \n");
2220 return;
2221 }
2222
2223 int32_t x=sdci[2]/10000;
2224 int32_t y=sdci[3]/10000;
2225 FONT* font=get_zc_font(sdci[4]/10000);
2226 int32_t color=sdci[5]/10000;
2227 int32_t bg_color=sdci[6]/10000; //-1 = transparent
2228 int32_t format_type=sdci[7]/10000;
2229 int32_t opacity=sdci[9]/10000;
2230 int32_t textstyle = sdci[10]/10000;
2231 int32_t shadow_color = sdci[11]/10000;
2232 //sdci[8] not needed :)
2233
2234 //safe check
2235 if(bg_color < -1) bg_color = -1;
2236
2237 if(opacity < 128)
2238 {
2239 int32_t width=zc_min(text_length(font, str->c_str()), 512);
2240 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
2241 clear_bitmap(pbmp);
2242 textout_styled_aligned_ex(pbmp, font, str->c_str(), 0, 0, textstyle, sstaLEFT, color, shadow_color, bg_color);
2243 textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
2244 if(format_type == 2) // right-sided text
2245 x-=width;
2246 else if(format_type == 1) // centered text
2247 x-=width/2;
2248 draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2249 destroy_bitmap(pbmp);
2250 }
2251 else // no opacity
2252 {
2253 textout_styled_aligned_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, textstyle, format_type, color, shadow_color, bg_color);
2254 }
2255 }
2256
2257
2258 void do_drawquadr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2259 {
2260 //sdci[1]=layer
2261 //sdci[2]=x1
2262 //sdci[3]=y1
2263 //sdci[4]=x2
2264 //sdci[5]=y2
2265 //sdci[6]=x3
2266 //sdci[7]=y3
2267 //sdci[8]=x4
2268 //sdci[9]=y4
2269 //sdci[10]=width
2270 //sdci[11]=height
2271 //sdci[12]=cset
2272 //sdci[13]=flip
2273 //sdci[14]=tile/combo
2274 //sdci[15]=polytype
2275
2276 int32_t x1 = sdci[2]/10000;
2277 int32_t y1 = sdci[3]/10000;
2278 int32_t x2 = sdci[4]/10000;
2279 int32_t y2 = sdci[5]/10000;
2280 int32_t x3 = sdci[6]/10000;
2281 int32_t y3 = sdci[7]/10000;
2282 int32_t x4 = sdci[8]/10000;
2283 int32_t y4 = sdci[9]/10000;
2284 int32_t w = sdci[10]/10000;
2285 int32_t h = sdci[11]/10000;
2286 int32_t color = sdci[12]/10000;
2287 int32_t flip=(sdci[13]/10000)&3;
2288 int32_t tile = sdci[14]/10000;
2289 int32_t polytype = sdci[15]/10000;
2290
2291 //todo: finish palette shading
2292 /*
2293 POLYTYPE_FLAT
2294 POLYTYPE_GCOL
2295 POLYTYPE_GRGB
2296 POLYTYPE_ATEX
2297 POLYTYPE_PTEX
2298 POLYTYPE_ATEX_MASK
2299 POLYTYPE_PTEX_MASK
2300 POLYTYPE_ATEX_LIT
2301 POLYTYPE_PTEX_LIT
2302 POLYTYPE_ATEX_MASK_LIT
2303 POLYTYPE_PTEX_MASK_LIT
2304 POLYTYPE_ATEX_TRANS
2305 POLYTYPE_PTEX_TRANS
2306 POLYTYPE_ATEX_MASK_TRANS
2307 POLYTYPE_PTEX_MASK_TRANS
2308 */
2309 polytype = vbound(polytype, 0, 14);
2310
2311 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
2312 {
2313 Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
2314 return; //non power of two error
2315 }
2316
2317 int32_t tex_width = w*16;
2318 int32_t tex_height = h*16;
2319
2320 BITMAP *tex;
2321
2322 bool mustDestroyBmp = false;
2323
2324 if ( tile > 65519 ) tex = zscriptDrawingRenderTarget->GetBitmapPtr(tile - 65519);
2325 else tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
2326
2327 if(!tex)
2328 {
2329 mustDestroyBmp = true;
2330 tex = create_bitmap_ex(8, tex_width, tex_height);
2331 clear_bitmap(tex);
2332 }
2333
2334 int32_t col[4];
2335 /*
2336 if( color < 0 )
2337 {
2338 col[0]=draw_container.color_buffer[0];
2339 col[1]=draw_container.color_buffer[1];
2340 col[2]=draw_container.color_buffer[2];
2341 col[3]=draw_container.color_buffer[3];
2342 }
2343 else */
2344 {
2345 col[0]=col[1]=col[2]=col[3]=color;
2346 }
2347
2348 if(tile > 0 && tile <= 65519) // TILE
2349 {
2350 TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
2351 }
2352
2353 if ( tile < 0 ) // COMBO
2354 {
2355 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
2356 const int32_t tiletodraw = combo_tile(c, x1, y1);
2357 flip = flip ^ c.flip;
2358
2359 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
2360 }
2361
2362 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
2363 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
2364 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
2365 V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(tex_width), 0, col[3] };
2366
2367 quad3d_f(bmp, polytype, tex, &V1, &V2, &V3, &V4);
2368
2369 if(mustDestroyBmp)
2370 destroy_bitmap(tex);
2371
2372 }
2373
2374
2375 void do_drawtriangler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2376 {
2377 //sdci[1]=layer
2378 //sdci[2]=x1
2379 //sdci[3]=y1
2380 //sdci[4]=x2
2381 //sdci[5]=y2
2382 //sdci[6]=x3
2383 //sdci[7]=y3
2384 //sdci[8]=width
2385 //sdci[9]=height
2386 //sdci[10]=cset
2387 //sdci[11]=flip
2388 //sdci[12]=tile/combo
2389 //sdci[13]=polytype
2390
2391 int32_t x1 = sdci[2]/10000;
2392 int32_t y1 = sdci[3]/10000;
2393 int32_t x2 = sdci[4]/10000;
2394 int32_t y2 = sdci[5]/10000;
2395 int32_t x3 = sdci[6]/10000;
2396 int32_t y3 = sdci[7]/10000;
2397 int32_t w = sdci[8]/10000;
2398 int32_t h = sdci[9]/10000;
2399 int32_t color = sdci[10]/10000;
2400 int32_t flip=(sdci[11]/10000)&3;
2401 int32_t tile = sdci[12]/10000;
2402 int32_t polytype = sdci[13]/10000;
2403
2404 polytype = vbound(polytype, 0, 14);
2405
2406 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
2407 {
2408 Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
2409 return; //non power of two error
2410 }
2411
2412 int32_t tex_width = w*16;
2413 int32_t tex_height = h*16;
2414
2415 bool mustDestroyBmp = false;
2416 BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
2417
2418 if(!tex)
2419 {
2420 mustDestroyBmp = true;
2421 tex = create_bitmap_ex(8, tex_width, tex_height);
2422 clear_bitmap(tex);
2423 }
2424
2425 int32_t col[3];
2426 /*
2427 if( color < 0 )
2428 {
2429 col[0]=draw_container.color_buffer[0];
2430 col[1]=draw_container.color_buffer[1];
2431 col[2]=draw_container.color_buffer[2];
2432 }
2433 else */
2434 {
2435 col[0]=col[1]=col[2]=color;
2436 }
2437
2438 if(tile > 0) // TILE
2439 {
2440 TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
2441 }
2442 else // COMBO
2443 {
2444 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
2445 const int32_t tiletodraw = combo_tile(c, x1, y1);
2446 flip = flip ^ c.flip;
2447
2448 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
2449 }
2450
2451 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
2452 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
2453 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
2454
2455
2456 triangle3d_f(bmp, polytype, tex, &V1, &V2, &V3);
2457
2458 if(mustDestroyBmp)
2459 destroy_bitmap(tex);
2460 }
2461
2462
2463 void do_drawbitmapr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2464 {
2465 //sdci[1]=layer
2466 //sdci[2]=bitmap
2467 //sdci[3]=sourcex
2468 //sdci[4]=sourcey
2469 //sdci[5]=sourcew
2470 //sdci[6]=sourceh
2471 //sdci[7]=destx
2472 //sdci[8]=desty
2473 //sdci[9]=destw
2474 //sdci[10]=desth
2475 //sdci[11]=rotation
2476 //sdci[12]=mask
2477
2478 int32_t bitmapIndex = sdci[2]/10000;
2479 int32_t sx = sdci[3]/10000;
2480 int32_t sy = sdci[4]/10000;
2481 int32_t sw = sdci[5]/10000;
2482 int32_t sh = sdci[6]/10000;
2483 int32_t dx = sdci[7]/10000;
2484 int32_t dy = sdci[8]/10000;
2485 int32_t dw = sdci[9]/10000;
2486 int32_t dh = sdci[10]/10000;
2487 float rot = sdci[11]/10000;
2488 bool masked = (sdci[12] != 0);
2489
2490 //bugfix
2491 sx = vbound(sx, 0, 512);
2492 sy = vbound(sy, 0, 512);
2493 sw = vbound(sw, 0, 512 - sx); //keep the w/h within range as well
2494 sh = vbound(sh, 0, 512 - sy);
2495
2496
2497 if(sx >= ZScriptDrawingRenderTarget::BitmapWidth || sy >= ZScriptDrawingRenderTarget::BitmapHeight)
2498 return;
2499
2500 bool stretched = (sw != dw || sh != dh);
2501
2502 BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
2503
2504 if(!sourceBitmap)
2505 {
2506 Z_message("Warning: Screen->DrawBitmap(%d) contains invalid data or is not initialized.\n", bitmapIndex);
2507 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
2508 return;
2509 }
2510
2511 BITMAP* subBmp = 0;
2512
2513 if(rot != 0)
2514 {
2515 subBmp = script_drawing_commands.AquireSubBitmap(dw, dh);
2516
2517 if(!subBmp)
2518 {
2519 Z_scripterrlog("DrawBitmap() failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
2520 return;
2521 }
2522 }
2523
2524
2525 dx = dx + xoffset;
2526 dy = dy + yoffset;
2527
2528 if(stretched)
2529 {
2530 if(masked)
2531 {
2532 if(rot != 0)
2533 {
2534 //if ( rot == 4096 ) { //translucent
2535 // masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2536 // //rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2537 // draw_trans_sprite(bmp, subBmp, dx, dy);
2538 // //draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, 0);
2539
2540
2541 // }
2542 //else {
2543 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2544 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2545 //rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2546 //
2547
2548 // }
2549 }
2550 else
2551 masked_stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2552 }
2553 else
2554 {
2555 if(rot != 0)
2556 {
2557 //if ( rot == 4096 ) { //translucent
2558 // stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2559 // draw_trans_sprite(bmp, subBmp, dx, dy);
2560 // }
2561 //else {
2562 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2563 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2564 // }
2565 }
2566 else
2567 stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2568 }
2569 }
2570 else
2571 {
2572 if(masked)
2573 {
2574 if(rot != 0)
2575 {
2576 //if ( rot == 4096 ) {//translucent
2577 // masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2578 //rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2579
2580 //masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2581 //rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2582 // draw_trans_sprite(bmp, subBmp, dx, dy);
2583 // }
2584 //else {
2585 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2586 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2587 // }
2588 }
2589 else
2590 masked_blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
2591 }
2592 else
2593 {
2594 if(rot != 0)
2595 {
2596 //if ( rot == 4096 ) { //translucent
2597 // blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2598 // draw_trans_sprite(bmp, subBmp, dx, dy);
2599 // }
2600 //else {
2601 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2602 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2603 // }
2604 }
2605 else
2606 blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
2607 }
2608 }
2609
2610 //cleanup
2611 if(subBmp)
2612 {
2613 script_drawing_commands.ReleaseSubBitmap(subBmp);
2614 }
2615 }
2616
2617
2618 //Draw]()
2619 void do_drawbitmapexr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2620 {
2621 /*
2622 //sdci[1]=layer
2623 //sdci[2]=bitmap
2624 //sdci[3]=sourcex
2625 //sdci[4]=sourcey
2626 //sdci[5]=sourcew
2627 //sdci[6]=sourceh
2628 //sdci[7]=destx
2629 //sdci[8]=desty
2630 //sdci[9]=destw
2631 //sdci[10]=desth
2632 //sdci[11]=rotation/angle
2633 //scdi[12] = pivot cx
2634 //sdci[13] = pivot cy
2635 //scdi[14] = effect flags
2636
2637
2638 const int32_t BITDX_NORMAL = 0;
2639 const int32_t BITDX_TRANS = 1; //Translucent
2640 const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
2641 const int32_t BITDX_HFLIP = 4; //Horizontal Flip
2642 const int32_t BITDX_VFLIP = 8; //Vertical Flip.
2643 //Note: Some modes cannot be combined. if a combination is not supported, an error
2644 // detailing this will be shown in allegro.log.
2645
2646 //scdi[15] = litcolour
2647 //The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2648 /not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2649
2650 //sdci[16]=mask
2651
2652 */
2653
2654 int32_t bitmapIndex = sdci[2]/10000;
2655 int32_t sx = sdci[3]/10000;
2656 int32_t sy = sdci[4]/10000;
2657 int32_t sw = sdci[5]/10000;
2658 int32_t sh = sdci[6]/10000;
2659 int32_t dx = sdci[7]/10000;
2660 int32_t dy = sdci[8]/10000;
2661 int32_t dw = sdci[9]/10000;
2662 int32_t dh = sdci[10]/10000;
2663 float rot = sdci[11]/10000;
2664 int32_t cx = sdci[12]/10000;
2665 int32_t cy = sdci[13]/10000;
2666 int32_t mode = sdci[14]/10000;
2667 int32_t litcolour = sdci[15]/10000;
2668 bool masked = (sdci[16] != 0);
2669
2670
2671
2672 //bugfix
2673 sx = vbound(sx, 0, 512);
2674 sy = vbound(sy, 0, 512);
2675 sw = vbound(sw, 0, 512 - sx); //keep the w/h within range as well
2676 sh = vbound(sh, 0, 512 - sy);
2677
2678
2679 if(sx >= ZScriptDrawingRenderTarget::BitmapWidth || sy >= ZScriptDrawingRenderTarget::BitmapHeight)
2680 return;
2681
2682 bool stretched = (sw != dw || sh != dh);
2683
2684 BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
2685
2686 if(!sourceBitmap)
2687 {
2688 Z_message("Warning: Screen->DrawBitmap(%d) contains invalid data or is not initialized.\n", bitmapIndex);
2689 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
2690 return;
2691 }
2692
2693 BITMAP* subBmp = 0;
2694
2695 /*
2696 if ( bitmapIndex == -1 ) {
2697 blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
2698 }
2699 */
2700
2701 if(rot != 0 || mode != 0)
2702 {
2703 subBmp = script_drawing_commands.AquireSubBitmap(dw, dh);
2704
2705 if(!subBmp)
2706 {
2707 Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
2708 return;
2709 }
2710 }
2711
2712
2713 dx = dx + xoffset;
2714 dy = dy + yoffset;
2715
2716 if(stretched)
2717 {
2718 if(masked) //stretched and masked
2719 {
2720 if ( rot == 0 ) //if not rotated
2721 {
2722 switch(mode)
2723 {
2724 case 1:
2725 //transparent
2726 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2727 draw_trans_sprite(bmp, subBmp, dx, dy);
2728 break;
2729
2730
2731 case 2:
2732 //pivot?
2733 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2734 pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2735 //Pivoting requires two more args
2736 break;
2737
2738 case 3:
2739 //pivot + trans
2740 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2741 pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2742 break;
2743
2744 case 4:
2745 //flip v
2746 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2747 draw_sprite_v_flip(bmp, subBmp, dx, dy);
2748 break;
2749
2750 case 5:
2751 //trans + v flip
2752 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2753 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
2754 break;
2755
2756 case 6:
2757 //pivot + v flip
2758 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2759 pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2760 break;
2761
2762 case 8:
2763 //vlip h
2764 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2765 draw_sprite_h_flip(bmp, subBmp, dx, dy);
2766 break;
2767
2768 case 9:
2769 //trans + h flip
2770 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2771 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
2772 break;
2773
2774 case 10:
2775 //flip H and pivot
2776 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
2777 //return error cannot pivot and h flip
2778 break;
2779
2780 case 12:
2781 //vh flip
2782 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2783 draw_sprite_vh_flip(bmp, subBmp, dx, dy);
2784 break;
2785
2786 case 13:
2787 //trans + vh flip
2788 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2789 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
2790 break;
2791
2792 case 14:
2793 //pivot and vh flip
2794 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
2795 //return error cannot both pivot and vh flip
2796 break;
2797
2798 case 16:
2799 //lit
2800 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2801 draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
2802 break;
2803
2804 case 18:
2805 //pivot, lit
2806 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2807 pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
2808 break;
2809
2810 case 20:
2811 //lit + v flip
2812 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2813 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
2814 break;
2815
2816 case 22:
2817 //Pivot, vflip, lit
2818 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2819 pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
2820 break;
2821
2822 case 24:
2823 //lit + h flip
2824 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2825 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
2826 break;
2827
2828 case 26:
2829 //pivot + lit + hflip
2830 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
2831 //return error cannot pivot, lit, and flip
2832 break;
2833
2834 case 28:
2835 //lit + vh flip
2836 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2837 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
2838 break;
2839
2840 case 32: //gouraud
2841 //Probably not wort supporting.
2842 //masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2843 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
2844 break;
2845
2846 case 0:
2847 //no effect
2848 masked_stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2849 break;
2850
2851
2852 default:
2853 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
2854
2855
2856 }
2857 } //end if not rotated
2858
2859 if ( rot != 0 ) //if rotated
2860 {
2861 switch(mode)
2862 {
2863 case 1:
2864 //transparent
2865 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2866 rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2867
2868 break;
2869
2870 case 2:
2871 //pivot?
2872 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2873 //return an error, cannot both rotate and pivot
2874 break;
2875
2876 case 3:
2877 //pivot + trans
2878 //return an error, cannot both rotate and pivot
2879 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2880 break;
2881
2882 case 4:
2883 //flip v
2884 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2885 rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2886 break;
2887
2888 case 5:
2889 //trans + v flip
2890 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2891 rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2892 break;
2893
2894 case 6:
2895 //pivot + v flip
2896 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2897 //return an error, cannot both rotate and pivot
2898 break;
2899
2900 case 8:
2901 //flip h
2902 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
2903 //return an error, cannot both rotate and flip H
2904 break;
2905
2906 case 9:
2907 //trans + h flip
2908 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
2909 //return an error, cannot rotate and flip a trans sprite
2910 break;
2911
2912 case 10:
2913 //flip H and pivot
2914 //return error cannot pivot and h flip
2915 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
2916 break;
2917
2918 case 12:
2919 //vh flip
2920 //return an error, cannot rotate and VH flip a trans sprite
2921 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
2922 break;
2923
2924 case 13:
2925 //trans + vh flip
2926 //return an error, cannot rotate and VH flip a trans sprite
2927 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
2928 break;
2929
2930 case 14:
2931 //pivot and vh flip
2932 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2933 //return error cannot both pivot and vh flip
2934 break;
2935
2936 case 16:
2937 //lit
2938 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2939 rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2940 break;
2941
2942 case 18:
2943 //pivot, lit
2944 //return an error, cannot both rotate and pivot
2945 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2946 break;
2947
2948 case 20:
2949 //lit + vflip
2950 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2951 rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2952 break;
2953
2954 case 22:
2955 //Pivot, vflip, lit
2956 //return an error, cannot both rotate and pivot
2957 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2958 break;
2959
2960 case 24:
2961 //lit + h flip
2962 //return an error, cannot both rotate and H flip
2963 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
2964 break;
2965
2966 case 26:
2967 //pivot + lit + hflip
2968 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
2969 //return error cannot pivot, lit, and flip
2970 break;
2971
2972 case 28:
2973 //lit + vh flip
2974 //return an error, cannot both rotate and VH flip
2975 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
2976 break;
2977
2978 case 32: //gouraud
2979 //Probably not wort supporting.
2980 //masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2981 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
2982 break;
2983
2984 case 0:
2985 //no effect.
2986 masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2987 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2988 break;
2989
2990 default:
2991 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
2992
2993 }
2994 }
2995 } //end if stretched and masked
2996
2997 else //stretched, not masked
2998 {
2999 if ( rot == 0 ) //if not rotated
3000 {
3001 switch(mode) {
3002 case 1:
3003 //transparent
3004 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3005 draw_trans_sprite(bmp, subBmp, dx, dy);
3006 break;
3007
3008
3009 case 2:
3010 //pivot?
3011 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3012 pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3013 //Pivoting requires two more args
3014 break;
3015
3016 case 3:
3017 //pivot + trans
3018 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3019 pivot_sprite_trans(bmp, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
3020 break;
3021
3022 case 4:
3023 //flip v
3024 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3025 draw_sprite_v_flip(bmp, subBmp, dx, dy);
3026 break;
3027
3028 case 5:
3029 //trans + v flip
3030 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3031 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3032 break;
3033
3034 case 6:
3035 //pivot + v flip
3036 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3037 pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3038 break;
3039
3040 case 8:
3041 //vlip h
3042 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3043 draw_sprite_h_flip(bmp, subBmp, dx, dy);
3044 break;
3045
3046 case 9:
3047 //trans + h flip
3048 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3049 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3050 break;
3051
3052 case 10:
3053 //flip H and pivot
3054 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3055 //return error cannot pivot and h flip
3056 break;
3057
3058 case 12:
3059 //vh flip
3060 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3061 draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3062 break;
3063
3064 case 13:
3065 //trans + vh flip
3066 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3067 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3068 break;
3069
3070 case 14:
3071 //pivot and vh flip
3072 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3073 //return error cannot both pivot and vh flip
3074 break;
3075
3076 case 16:
3077 //lit
3078 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3079 draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3080 break;
3081
3082 case 18:
3083 //pivot, lit
3084 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3085 pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3086 break;
3087
3088 case 20:
3089 //lit + v flip
3090 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3091 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3092 break;
3093
3094 case 22:
3095 //Pivot, vflip, lit
3096 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3097 pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3098 break;
3099
3100 case 24:
3101 //lit + h flip
3102 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3103 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3104 break;
3105
3106 case 26:
3107 //pivot + lit + hflip
3108 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3109 //return error cannot pivot, lit, and flip
3110 break;
3111
3112 case 28:
3113 //lit + vh flip
3114 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3115 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3116 break;
3117
3118 case 32: //gouraud
3119 //Probably not wort supporting.
3120 //stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3121 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3122 break;
3123
3124 case 0:
3125 //no effect
3126 stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
3127 break;
3128
3129
3130 default:
3131 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3132
3133
3134 }
3135 } //end if not rotated
3136
3137 if ( rot != 0 ) //if rotated
3138 {
3139 switch(mode)
3140 {
3141 case 1:
3142 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3143 rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3144
3145 break;
3146
3147 case 2:
3148 //pivot?
3149 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3150 //return an error, cannot both rotate and pivot
3151 break;
3152
3153 case 3:
3154 //pivot + trans
3155 //return an error, cannot both rotate and pivot
3156 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3157 break;
3158
3159 case 4:
3160 //flip v
3161 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3162 rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3163 break;
3164
3165 case 5:
3166 //trans + v flip
3167 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3168 rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3169 break;
3170
3171 case 6:
3172 //pivot + v flip
3173 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3174 //return an error, cannot both rotate and pivot
3175 break;
3176
3177 case 8:
3178 //flip h
3179 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3180 //return an error, cannot both rotate and flip H
3181 break;
3182
3183 case 9:
3184 //trans + h flip
3185 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3186 //return an error, cannot rotate and flip a trans sprite
3187 break;
3188
3189 case 10:
3190 //flip H and pivot
3191 //return error cannot pivot and h flip
3192 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3193 break;
3194
3195 case 12:
3196 //vh flip
3197 //return an error, cannot rotate and VH flip a trans sprite
3198 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3199 break;
3200
3201 case 13:
3202 //trans + vh flip
3203 //return an error, cannot rotate and VH flip a trans sprite
3204 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3205 break;
3206
3207 case 14:
3208 //pivot and vh flip
3209 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3210 //return error cannot both pivot and vh flip
3211 break;
3212
3213 case 16:
3214 //lit
3215 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3216 rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3217 break;
3218
3219 case 18:
3220 //pivot, lit
3221 //return an error, cannot both rotate and pivot
3222 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3223 break;
3224
3225 case 20:
3226 //lit + vflip
3227 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3228 rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3229 break;
3230
3231 case 22:
3232 //Pivot, vflip, lit
3233 //return an error, cannot both rotate and pivot
3234 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3235 break;
3236
3237 case 24:
3238 //lit + h flip
3239 //return an error, cannot both rotate and H flip
3240 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3241 break;
3242
3243 case 26:
3244 //pivot + lit + hflip
3245 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3246 //return error cannot pivot, lit, and flip
3247 break;
3248
3249 case 28:
3250 //lit + vh flip
3251 //return an error, cannot both rotate and VH flip
3252 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3253 break;
3254
3255 case 32: //gouraud
3256 //Probably not wort supporting.
3257 //stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3258 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3259 break;
3260
3261 case 0:
3262 //no effect.
3263 stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3264 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3265 break;
3266
3267 default:
3268 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3269
3270 }
3271 }
3272
3273 } //end if stretched, but not masked
3274 }
3275 else //not stretched
3276 {
3277
3278 if(masked) //if masked, but not stretched
3279 {
3280
3281 if ( rot == 0 ) //if not rotated
3282 {
3283 switch(mode)
3284 {
3285 case 1:
3286 //transparent
3287 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3288 draw_trans_sprite(bmp, subBmp, dx, dy);
3289 break;
3290
3291
3292 case 2:
3293 //pivot?
3294 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3295 pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3296 //Pivoting requires two more args
3297 break;
3298
3299 case 3:
3300 //pivot + trans
3301 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3302 pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3303 break;
3304
3305 case 4:
3306 //flip v
3307 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3308 draw_sprite_v_flip(bmp, subBmp, dx, dy);
3309 break;
3310
3311 case 5:
3312 //trans + v flip
3313 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3314 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3315 break;
3316
3317 case 6:
3318 //pivot + v flip
3319 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3320 pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3321 break;
3322
3323 case 8:
3324 //vlip h
3325 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3326 draw_sprite_h_flip(bmp, subBmp, dx, dy);
3327 break;
3328
3329 case 9:
3330 //trans + h flip
3331 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3332 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3333 break;
3334
3335 case 10:
3336 //flip H and pivot
3337 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3338 //return error cannot pivot and h flip
3339 break;
3340
3341 case 12:
3342 //vh flip
3343 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3344 draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3345 break;
3346
3347 case 13:
3348 //trans + vh flip
3349 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3350 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3351 break;
3352
3353 case 14:
3354 //pivot and vh flip
3355 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3356 //return error cannot both pivot and vh flip
3357 break;
3358
3359 case 16:
3360 //lit
3361 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3362 draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3363 break;
3364
3365 case 18:
3366 //pivot, lit
3367 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3368 pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3369 break;
3370
3371 case 20:
3372 //lit + v flip
3373 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3374 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3375 break;
3376
3377 case 22:
3378 //Pivot, vflip, lit
3379 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3380 pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3381 break;
3382
3383 case 24:
3384 //lit + h flip
3385 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3386 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3387 break;
3388
3389 case 26:
3390 //pivot + lit + hflip
3391 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3392 //return error cannot pivot, lit, and flip
3393 break;
3394
3395 case 28:
3396 //lit + vh flip
3397 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3398 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3399 break;
3400
3401 case 32: //gouraud
3402 //Probably not wort supporting.
3403 //stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3404 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3405 break;
3406
3407 case 0:
3408 //no effect
3409 masked_blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
3410 break;
3411
3412
3413 default:
3414 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3415
3416
3417 }
3418 } //end if not rotated
3419
3420 if ( rot != 0 ) //if rotated
3421 {
3422 switch(mode)
3423 {
3424 case 1:
3425 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh); //transparent
3426 rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3427
3428 break;
3429
3430 case 2:
3431 //pivot?
3432 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3433 //return an error, cannot both rotate and pivot
3434 break;
3435
3436 case 3:
3437 //pivot + trans
3438 //return an error, cannot both rotate and pivot
3439 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3440 break;
3441
3442 case 4:
3443 //flip v
3444 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3445 rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3446 break;
3447
3448 case 5:
3449 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
3450 rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3451 break;
3452
3453 case 6:
3454 //pivot + v flip
3455 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3456 //return an error, cannot both rotate and pivot
3457 break;
3458
3459 case 8:
3460 //flip h
3461 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3462 //return an error, cannot both rotate and flip H
3463 break;
3464
3465 case 9:
3466 //trans + h flip
3467 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3468 //return an error, cannot rotate and flip a trans sprite
3469 break;
3470
3471 case 10:
3472 //flip H and pivot
3473 //return error cannot pivot and h flip
3474 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3475 break;
3476
3477 case 12:
3478 //vh flip
3479 //return an error, cannot rotate and VH flip a trans sprite
3480 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3481 break;
3482
3483 case 13:
3484 //trans + vh flip
3485 //return an error, cannot rotate and VH flip a trans sprite
3486 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3487 break;
3488
3489 case 14:
3490 //pivot and vh flip
3491 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3492 //return error cannot both pivot and vh flip
3493 break;
3494
3495 case 16:
3496 //lit
3497 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3498 rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3499 break;
3500
3501 case 18:
3502 //pivot, lit
3503 //return an error, cannot both rotate and pivot
3504 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3505 break;
3506
3507 case 20:
3508 //lit + vflip
3509 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3510 rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3511 break;
3512
3513 case 22:
3514 //Pivot, vflip, lit
3515 //return an error, cannot both rotate and pivot
3516 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3517 break;
3518
3519 case 24:
3520 //lit + h flip
3521 //return an error, cannot both rotate and H flip
3522 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3523 break;
3524
3525 case 26:
3526 //pivot + lit + hflip
3527 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3528 //return error cannot pivot, lit, and flip
3529 break;
3530
3531 case 28:
3532 //lit + vh flip
3533 //return an error, cannot both rotate and VH flip
3534 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3535 break;
3536
3537 case 32: //gouraud
3538 //Probably not wort supporting.
3539 //stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3540 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3541 break;
3542
3543 case 0:
3544 //no effect.
3545 masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3546 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3547 break;
3548
3549 default:
3550 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3551
3552 }
3553 } //end rtated, masked
3554 } //end if masked
3555
3556 else //not masked, and not stretched; just blit
3557 {
3558
3559 if ( rot == 0 ) //if not rotated
3560 {
3561 switch(mode)
3562 {
3563 case 1:
3564 //transparent
3565 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3566 draw_trans_sprite(bmp, subBmp, dx, dy);
3567 break;
3568
3569
3570 case 2:
3571 //pivot?
3572 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3573 pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3574 //Pivoting requires two more args
3575 break;
3576
3577 case 3:
3578 //pivot + trans
3579 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3580 pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3581 break;
3582
3583 case 4:
3584 //flip v
3585 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3586 draw_sprite_v_flip(bmp, subBmp, dx, dy);
3587 break;
3588
3589 case 5:
3590 //trans + v flip
3591 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3592 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3593 break;
3594
3595 case 6:
3596 //pivot + v flip
3597 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3598 pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3599 break;
3600
3601 case 8:
3602 //vlip h
3603 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3604 draw_sprite_h_flip(bmp, subBmp, dx, dy);
3605 break;
3606
3607 case 9:
3608 //trans + h flip
3609 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3610 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3611 break;
3612
3613 case 10:
3614 //flip H and pivot
3615 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3616 //return error cannot pivot and h flip
3617 break;
3618
3619 case 12:
3620 //vh flip
3621 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3622 draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3623 break;
3624
3625 case 13:
3626 //trans + vh flip
3627 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3628 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3629 break;
3630
3631 case 14:
3632 //pivot and vh flip
3633 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3634 //return error cannot both pivot and vh flip
3635 break;
3636
3637 case 16:
3638 //lit
3639 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3640 draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3641 break;
3642
3643 case 18:
3644 //pivot, lit
3645 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3646 pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3647 break;
3648
3649 case 20:
3650 //lit + v flip
3651 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3652 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3653 break;
3654
3655 case 22:
3656 //Pivot, vflip, lit
3657 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3658 pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3659 break;
3660
3661 case 24:
3662 //lit + h flip
3663 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3664 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3665 break;
3666
3667 case 26:
3668 //pivot + lit + hflip
3669 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3670 //return error cannot pivot, lit, and flip
3671 break;
3672
3673 case 28:
3674 //lit + vh flip
3675 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3676 draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3677 break;
3678
3679 case 32: //gouraud
3680 //Probably not wort supporting.
3681 //blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3682 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3683 break;
3684
3685 case 0:
3686 //no effect
3687 blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
3688 break;
3689
3690
3691 default:
3692 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3693
3694
3695 }
3696 } //end if not rotated
3697
3698 if ( rot != 0 ) //if rotated
3699 {
3700 switch(mode)
3701 {
3702 case 1:
3703 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);//transparent
3704 rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3705
3706 break;
3707
3708 case 2:
3709 //pivot?
3710 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3711 //return an error, cannot both rotate and pivot
3712 break;
3713
3714 case 3:
3715 //pivot + trans
3716 //return an error, cannot both rotate and pivot
3717 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3718 break;
3719
3720 case 4:
3721 //flip v
3722 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3723 rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3724 break;
3725
3726 case 5:
3727 //trans + v flip
3728 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3729 rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3730 break;
3731
3732 case 6:
3733 //pivot + v flip
3734 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3735 //return an error, cannot both rotate and pivot
3736 break;
3737
3738 case 8:
3739 //flip h
3740 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3741 //return an error, cannot both rotate and flip H
3742 break;
3743
3744 case 9:
3745 //trans + h flip
3746 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3747 //return an error, cannot rotate and flip a trans sprite
3748 break;
3749
3750 case 10:
3751 //flip H and pivot
3752 //return error cannot pivot and h flip
3753 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3754 break;
3755
3756 case 12:
3757 //vh flip
3758 //return an error, cannot rotate and VH flip a trans sprite
3759 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3760 break;
3761
3762 case 13:
3763 //trans + vh flip
3764 //return an error, cannot rotate and VH flip a trans sprite
3765 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3766 break;
3767
3768 case 14:
3769 //pivot and vh flip
3770 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3771 //return error cannot both pivot and vh flip
3772 break;
3773
3774 case 16:
3775 //lit
3776 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3777 rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3778 break;
3779
3780 case 18:
3781 //pivot, lit
3782 //return an error, cannot both rotate and pivot
3783 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3784 break;
3785
3786 case 20:
3787 //lit + vflip
3788 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3789 rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3790 break;
3791
3792 case 22:
3793 //Pivot, vflip, lit
3794 //return an error, cannot both rotate and pivot
3795 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3796 break;
3797
3798 case 24:
3799 //lit + h flip
3800 //return an error, cannot both rotate and H flip
3801 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3802 break;
3803
3804 case 26:
3805 //pivot + lit + hflip
3806 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3807 //return error cannot pivot, lit, and flip
3808 break;
3809
3810 case 28:
3811 //lit + vh flip
3812 //return an error, cannot both rotate and VH flip
3813 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3814 break;
3815
3816 case 32: //gouraud
3817 //Probably not wort supporting.
3818 //blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3819 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3820 break;
3821
3822 case 0:
3823 //no effect.
3824 blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3825 rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3826 break;
3827
3828 default:
3829 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3830
3831 }
3832 } //end if rotated
3833 } //end if not masked
3834 } //end if not stretched
3835
3836 //cleanup
3837 if(subBmp)
3838 {
3839 script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
3840 }
3841 }
3842
3843
3844 void do_drawquad3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
3845 {
3846 //sdci[1]=layer
3847 //sdci[2]=pos[12]
3848 //sdci[3]=uv[8]
3849 //sdci[4]=color[4]
3850 //sdci[5]=size[2]
3851 //sdci[6]=flip
3852 //sdci[7]=tile/combo
3853 //sdci[8]=polytype
3854
3855 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
3856
3857 if(!v_ptr)
3858 {
3859 al_trace("Quad3d: Vector pointer is null! Internal error. \n");
3860 return;
3861 }
3862
3863 std::vector<int32_t> &v = *v_ptr;
3864
3865 if(v.empty())
3866 return;
3867
3868 int32_t* pos = &v[0];
3869 int32_t* uv = &v[12];
3870 int32_t* col = &v[20];
3871 int32_t* size = &v[24];
3872
3873 int32_t w = size[0]; //magic numerical constants... yuck.
3874 int32_t h = size[1];
3875 int32_t flip = (sdci[6]/10000)&3;
3876 int32_t tile = sdci[7]/10000;
3877 int32_t polytype = sdci[8]/10000;
3878
3879 polytype = vbound(polytype, 0, 14);
3880
3881 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
3882 {
3883 Z_message("Quad3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
3884 return; //non power of two error
3885 }
3886
3887 int32_t tex_width = w*16;
3888 int32_t tex_height = h*16;
3889
3890 bool mustDestroyBmp = false;
3891 BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
3892
3893 if(!tex)
3894 {
3895 mustDestroyBmp = true;
3896 tex = create_bitmap_ex(8, tex_width, tex_height);
3897 clear_bitmap(tex);
3898 }
3899
3900 if(tile > 0) // TILE
3901 {
3902 TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
3903 }
3904 else // COMBO
3905 {
3906 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
3907 const int32_t tiletodraw = combo_tile(c, 0, 0);
3908 flip = flip ^ c.flip;
3909
3910 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
3911 }
3912
3913 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
3914 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
3915 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
3916 V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
3917
3918 quad3d_f(bmp, polytype, tex, &V1, &V2, &V3, &V4);
3919
3920 if(mustDestroyBmp)
3921 destroy_bitmap(tex);
3922
3923 }
3924
3925
3926
3927 void do_drawtriangle3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
3928 {
3929 //sdci[1]=layer
3930 //sdci[2]=pos[9]
3931 //sdci[3]=uv[6]
3932 //sdci[4]=color[3]
3933 //sdci[5]=size[2]
3934 //sdci[6]=flip
3935 //sdci[7]=tile/combo
3936 //sdci[8]=polytype
3937
3938 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
3939
3940 if(!v_ptr)
3941 {
3942 al_trace("Triange3d: Vector pointer is null! Internal error. \n");
3943 return;
3944 }
3945
3946 std::vector<int32_t> &v = *v_ptr;
3947
3948 if(v.empty())
3949 return;
3950
3951 int32_t* pos = &v[0];
3952 int32_t* uv = &v[9];
3953 int32_t* col = &v[15];
3954 int32_t* size = &v[18];
3955
3956 int32_t w = size[0]; //magic numerical constants... yuck.
3957 int32_t h = size[1];
3958 int32_t flip = (sdci[6]/10000)&3;
3959 int32_t tile = sdci[7]/10000;
3960 int32_t polytype = sdci[8]/10000;
3961
3962 polytype = vbound(polytype, 0, 14);
3963
3964 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
3965 {
3966 Z_message("Triangle3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
3967 return; //non power of two error
3968 }
3969
3970 int32_t tex_width = w*16;
3971 int32_t tex_height = h*16;
3972
3973 bool mustDestroyBmp = false;
3974 BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
3975
3976 if(!tex)
3977 {
3978 mustDestroyBmp = true;
3979 tex = create_bitmap_ex(8, tex_width, tex_height);
3980 clear_bitmap(tex);
3981 }
3982
3983 if(tile > 0) // TILE
3984 {
3985 TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
3986 }
3987 else // COMBO
3988 {
3989 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
3990 const int32_t tiletodraw = combo_tile(c, 0, 0);
3991 flip = flip ^ c.flip;
3992
3993 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
3994 }
3995
3996 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
3997 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
3998 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
3999
4000 triangle3d_f(bmp, polytype, tex, &V1, &V2, &V3);
4001
4002 if(mustDestroyBmp)
4003 destroy_bitmap(tex);
4004
4005 }
4006
4007 void bmp_do_rectr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4008 {
4009 //Z_scripterrlog("rect sdci[13] is: %d\n", sdci[13]);
4010 //sdci[1]=layer
4011 //sdci[2]=x
4012 //sdci[3]=y
4013 //sdci[4]=x2
4014 //sdci[5]=y2
4015 //sdci[6]=color
4016 //sdci[7]=scale factor
4017 //sdci[8]=rotation anchor x
4018 //sdci[9]=rotation anchor y
4019 //sdci[10]=rotation angle
4020 //sdci[11]=fill
4021 //sdci[12]=opacity
4022 //sdci[17] Bitmap Pointer
4023 if(sdci[7]==0) //scale
4024 {
4025 return;
4026 }
4027 if ( sdci[17] <= 0 )
4028 {
4029 Z_scripterrlog("bitmap->Rectangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4030 return;
4031 }
4032 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4033 if ( refbmp == NULL ) return;
4034
4035 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4036
4037 int32_t x1=sdci[2]/10000;
4038 int32_t y1=sdci[3]/10000;
4039 int32_t x2=sdci[4]/10000;
4040 int32_t y2=sdci[5]/10000;
4041
4042
4043 if(x1>x2)
4044 {
4045 zc_swap(x1,x2);
4046 }
4047
4048 if(y1>y2)
4049 {
4050 zc_swap(y1,y2);
4051 }
4052
4053 if(sdci[7] != 10000)
4054 {
4055 int32_t w=x2-x1+1;
4056 int32_t h=y2-y1+1;
4057 int32_t w2=(w*sdci[7])/10000;
4058 int32_t h2=(h*sdci[7])/10000;
4059 x1=x1-((w2-w)/2);
4060 x2=x2+((w2-w)/2);
4061 y1=y1-((h2-h)/2);
4062 y2=y2+((h2-h)/2);
4063 }
4064
4065 int32_t color=sdci[6]/10000;
4066
4067 if(sdci[12]/10000<=127) //translucent
4068 {
4069 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4070 }
4071
4072 if(sdci[10]==0) //no rotation
4073 {
4074 if(sdci[11]) //filled
4075 {
4076 rectfill(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4077 }
4078 else //outline
4079 {
4080 rect(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4081 }
4082 }
4083 else //rotate
4084 {
4085 int32_t xy[16];
4086 int32_t rx=sdci[8]/10000;
4087 int32_t ry=sdci[9]/10000;
4088 fixed ra1=itofix(sdci[10]%10000)/10000;
4089 fixed ra2=itofix(sdci[10]/10000);
4090 fixed ra=ra1+ra2;
4091 ra = (ra/360)*256;
4092
4093 fixed fcosa = fixcos(ra);
4094 fixed fsina = fixsin(ra);
4095
4096 xy[ 0]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry))); //x1
4097 xy[ 1]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry))); //y1
4098 xy[ 2]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y1 - ry))); //x2
4099 xy[ 3]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y1 - ry))); //y1
4100 xy[ 4]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry))); //x2
4101 xy[ 5]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry))); //y2
4102 xy[ 6]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y2 - ry))); //x1
4103 xy[ 7]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y2 - ry))); //y2
4104 xy[ 8]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry + 1))); //x1
4105 xy[ 9]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry + 1))); //y1
4106 xy[10]=xoffset+rx + fixtoi((fcosa * (x2 - rx - 1) - fsina * (y1 - ry))); //x2
4107 xy[11]=yoffset+ry + fixtoi((fsina * (x2 - rx - 1) + fcosa * (y1 - ry))); //y1
4108 xy[12]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry - 1))); //x2
4109 xy[13]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry - 1))); //y2
4110 xy[14]=xoffset+rx + fixtoi((fcosa * (x1 - rx + 1) - fsina * (y2 - ry))); //x1
4111 xy[15]=yoffset+ry + fixtoi((fsina * (x1 - rx + 1) + fcosa * (y2 - ry))); //y2
4112
4113 if(sdci[11]) //filled
4114 {
4115 polygon(refbmp, 4, xy, color);
4116 }
4117 else //outline
4118 {
4119 line(refbmp, xy[0], xy[1], xy[10], xy[11], color);
4120 line(refbmp, xy[2], xy[3], xy[12], xy[13], color);
4121 line(refbmp, xy[4], xy[5], xy[14], xy[15], color);
4122 line(refbmp, xy[6], xy[7], xy[ 8], xy[ 9], color);
4123 }
4124 }
4125
4126 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4127 }
4128
4129 void bmp_do_framer(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4130 {
4131 //sdci[1]=layer
4132 //sdci[2]=x
4133 //sdci[3]=y
4134 //sdci[4]=tile
4135 //sdci[5]=cset
4136 //sdci[6]=width
4137 //sdci[7]=height
4138 //sdci[8]=overlay
4139 //sdci[9]=opacity
4140
4141 if ( sdci[17] <= 0 )
4142 {
4143 Z_scripterrlog("bitmap->DrawFrame() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4144 return;
4145 }
4146 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4147 if ( refbmp == NULL ) return;
4148
4149 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4150
4151 int32_t x=sdci[2]/10000;
4152 int32_t y=sdci[3]/10000;
4153
4154 int32_t tile=sdci[4]/10000;
4155 int32_t cs=sdci[5]/10000;
4156 int32_t w=sdci[6]/10000;
4157 int32_t h=sdci[7]/10000;
4158 bool overlay=sdci[8];
4159 bool trans=(sdci[9]/10000<=127);
4160
4161 frame2x2(refbmp, &QMisc, x + xoffset, y + yoffset, tile, cs, w, h, 0, overlay, trans);
4162 }
4163
4164
4165 void bmp_do_circler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4166 {
4167 //sdci[1]=layer
4168 //sdci[2]=x
4169 //sdci[3]=y
4170 //sdci[4]=radius
4171 //sdci[5]=color
4172 //sdci[6]=scale factor
4173 //sdci[7]=rotation anchor x
4174 //sdci[8]=rotation anchor y
4175 //sdci[9]=rotation angle
4176 //sdci[10]=fill
4177 //sdci[11]=opacity
4178 //sdci[17] Bitmap Pointer
4179 if(sdci[6]==0) //scale
4180 {
4181 return;
4182 }
4183 if ( sdci[17] <= 0 )
4184 {
4185 Z_scripterrlog("bitmap->Circle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4186 return;
4187 }
4188 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4189 if ( refbmp == NULL ) return;
4190
4191 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4192
4193 int32_t x1=sdci[2]/10000;
4194 int32_t y1=sdci[3]/10000;
4195 qword r=sdci[4];
4196
4197 if(sdci[6] != 10000)
4198 {
4199 r*=sdci[6];
4200 r/=10000;
4201 }
4202
4203 r/=10000;
4204 int32_t color=sdci[5]/10000;
4205
4206 if(sdci[11]/10000<=127) //translucent
4207 {
4208 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4209 }
4210
4211 if(sdci[9]!=0&&(sdci[2]!=sdci[7]||sdci[3]!=sdci[8])) //rotation
4212 {
4213 int32_t xy[2];
4214 int32_t rx=sdci[7]/10000;
4215 int32_t ry=sdci[8]/10000;
4216 fixed ra1=itofix(sdci[9]%10000)/10000;
4217 fixed ra2=itofix(sdci[9]/10000);
4218 fixed ra=ra1+ra2;
4219 ra = (ra/360)*256;
4220
4221 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4222 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4223 x1=xy[0];
4224 y1=xy[1];
4225 }
4226
4227 if(sdci[10]) //filled
4228 {
4229 circlefill(refbmp, x1+xoffset, y1+yoffset, r, color);
4230 }
4231 else //outline
4232 {
4233 circle(refbmp, x1+xoffset, y1+yoffset, r, color);
4234 }
4235
4236 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4237 }
4238
4239
4240 void bmp_do_arcr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4241 {
4242 //sdci[1]=layer
4243 //sdci[2]=x
4244 //sdci[3]=y
4245 //sdci[4]=radius
4246 //sdci[5]=start angle
4247 //sdci[6]=end angle
4248 //sdci[7]=color
4249 //sdci[8]=scale factor
4250 //sdci[9]=rotation anchor x
4251 //sdci[10]=rotation anchor y
4252 //sdci[11]=rotation angle
4253 //sdci[12]=closed
4254 //sdci[13]=fill
4255 //sdci[14]=opacity
4256 //sdci[17] Bitmap Pointer
4257
4258 if(sdci[8]==0) //scale
4259 {
4260 return;
4261 }
4262 if ( sdci[17] <= 0 )
4263 {
4264 Z_scripterrlog("bitmap->Arc() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4265 return;
4266 }
4267 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4268 if ( refbmp == NULL ) return;
4269
4270 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4271
4272 int32_t cx=sdci[2]/10000;
4273 int32_t cy=sdci[3]/10000;
4274 qword r=sdci[4];
4275
4276 if(sdci[8] != 10000)
4277 {
4278 r*=sdci[8];
4279 r/=10000;
4280 }
4281
4282 r/=10000;
4283
4284 int32_t color=sdci[7]/10000;
4285
4286 fixed ra1=itofix(sdci[11]%10000)/10000;
4287 fixed ra2=itofix(sdci[11]/10000);
4288 fixed ra=ra1+ra2;
4289 ra = (ra/360)*256;
4290
4291
4292 fixed a1=itofix(sdci[5]%10000)/10000;
4293 fixed a2=itofix(sdci[5]/10000);
4294 fixed sa=a1+a2;
4295 sa = (sa/360)*256;
4296
4297 a1=itofix(sdci[6]%10000)/10000;
4298 a2=itofix(sdci[6]/10000);
4299 fixed ea=a1+a2;
4300 ea = (ea/360)*256;
4301
4302 if(sdci[11]!=0) //rotation
4303 {
4304 int32_t rx=sdci[9]/10000;
4305 int32_t ry=sdci[10]/10000;
4306
4307 cx=rx + fixtoi((fixcos(ra) * (cx - rx) - fixsin(ra) * (cy - ry))); //x1
4308 cy=ry + fixtoi((fixsin(ra) * (cx - rx) + fixcos(ra) * (cy - ry))); //y1
4309 ea-=ra;
4310 sa-=ra;
4311 }
4312
4313 int32_t fx=cx+fixtoi(fixcos(-(ea+sa)/2)*r/2);
4314 int32_t fy=cy+fixtoi(fixsin(-(ea+sa)/2)*r/2);
4315
4316 if(sdci[12]) //closed
4317 {
4318 if(sdci[13]) //filled
4319 {
4320 clear_bitmap(prim_bmp);
4321 arc(prim_bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4322 line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
4323 line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
4324 floodfill(prim_bmp, zc_max(0,fx)+xoffset, zc_max(0,fy)+yoffset, color);
4325
4326 if(sdci[14]/10000<=127) //translucent
4327 {
4328 draw_trans_sprite(refbmp, prim_bmp, 0,0);
4329 }
4330 else
4331 {
4332 draw_sprite(refbmp, prim_bmp, 0,0);
4333 }
4334 }
4335 else
4336 {
4337 arc(refbmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4338 line(refbmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
4339 line(refbmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
4340 }
4341 }
4342 else
4343 {
4344 if(sdci[14]/10000<=127) //translucent
4345 {
4346 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4347 }
4348
4349 arc(refbmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4350 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4351 }
4352 }
4353
4354
4355 void bmp_do_ellipser(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4356 {
4357 //sdci[1]=layer
4358 //sdci[2]=x
4359 //sdci[3]=y
4360 //sdci[4]=radiusx
4361 //sdci[5]=radiusy
4362 //sdci[6]=color
4363 //sdci[7]=scale factor
4364 //sdci[8]=rotation anchor x
4365 //sdci[9]=rotation anchor y
4366 //sdci[10]=rotation angle
4367 //sdci[11]=fill
4368 //sdci[12]=opacity
4369 //sdci[17] Bitmap Pointer
4370
4371 if(sdci[7]==0) //scale
4372 {
4373 return;
4374 }
4375 if ( sdci[17] <= 0 )
4376 {
4377 Z_scripterrlog("bitmap->Ellipse() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4378 return;
4379 }
4380 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4381 if ( refbmp == NULL ) return;
4382
4383 int32_t x1=sdci[2]/10000;
4384 int32_t y1=sdci[3]/10000;
4385 int32_t radx=sdci[4]/10000;
4386 radx*=sdci[7]/10000;
4387 int32_t rady=sdci[5]/10000;
4388 rady*=sdci[7]/10000;
4389 int32_t color=sdci[6]/10000;
4390 float rotation = sdci[10]/10000;
4391
4392 int32_t rx=sdci[8]/10000;
4393 int32_t ry=sdci[9]/10000;
4394 fixed ra1=itofix(sdci[10]%10000)/10000;
4395 fixed ra2=itofix(sdci[10]/10000);
4396 fixed ra=ra1+ra2;
4397 ra = (ra/360)*256;
4398
4399 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4400
4401 int32_t xy[2];
4402 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4403 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4404 x1=xy[0];
4405 y1=xy[1];
4406
4407 if(radx<1||rady<1||radx>255||rady>255) return;
4408
4409 BITMAP* bitty = script_drawing_commands.AquireSubBitmap(radx*2+1, rady*2+1);
4410
4411 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4412
4413 if(sdci[11]) //filled
4414 {
4415
4416 if(sdci[12]/10000<128) //translucent
4417 {
4418 clear_bitmap(prim_bmp);
4419 ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
4420 rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4421 draw_trans_sprite(refbmp, prim_bmp, 0, 0);
4422 }
4423 else // no opacity
4424 {
4425 ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
4426 rotate_sprite(refbmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4427 }
4428 }
4429 else //not filled
4430 {
4431 if(sdci[12]/10000<128) //translucent
4432 {
4433 clear_bitmap(prim_bmp);
4434 ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
4435 rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4436 draw_trans_sprite(refbmp, prim_bmp, 0, 0);
4437 }
4438 else // no opacity
4439 {
4440 ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
4441 rotate_sprite(refbmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4442 }
4443 }
4444
4445 // Since 0 is the transparent color, the stuff above will fail if the ellipse color is also 0.
4446 // Instead, it uses color 255 and replaces it afterward. That'll also screw up color 255 around
4447 // the ellipse, but it shouldn't be used anyway.
4448 if(color==0)
4449 {
4450 // This is very slow, so check the smallest possible square
4451 int32_t endx=zc_min(bmp->w-1, x1+zc_max(radx, rady));
4452 int32_t endy=zc_min(bmp->h-1, y1+zc_max(radx, rady));
4453
4454 for(int32_t y=zc_max(0, y1-zc_max(radx, rady)); y<=endy; y++)
4455 for(int32_t x=zc_max(0, x1-zc_max(radx, rady)); x<=endx; x++)
4456 if(getpixel(refbmp, x, y)==255)
4457 putpixel(refbmp, x, y, 0);
4458 }
4459
4460 script_drawing_commands.ReleaseSubBitmap(bitty);
4461 }
4462
4463
4464 void bmp_do_liner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4465 {
4466 //sdci[1]=layer
4467 //sdci[2]=x
4468 //sdci[3]=y
4469 //sdci[4]=x2
4470 //sdci[5]=y2
4471 //sdci[6]=color
4472 //sdci[7]=scale factor
4473 //sdci[8]=rotation anchor x
4474 //sdci[9]=rotation anchor y
4475 //sdci[10]=rotation angle
4476 //sdci[11]=opacity
4477 //sdci[17] Bitmap Pointer
4478 if(sdci[7]==0) //scale
4479 {
4480 return;
4481 }
4482
4483 if ( sdci[17] <= 0 )
4484 {
4485 Z_scripterrlog("bitmap->Line() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4486 return;
4487 }
4488
4489 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4490 if ( refbmp == NULL ) return;
4491
4492 int32_t x1=sdci[2]/10000;
4493 int32_t y1=sdci[3]/10000;
4494 int32_t x2=sdci[4]/10000;
4495 int32_t y2=sdci[5]/10000;
4496
4497 if(sdci[7] != 10000)
4498 {
4499 int32_t w=x2-x1+1;
4500 int32_t h=y2-y1+1;
4501 int32_t w2=int32_t(w*((double)sdci[7]/10000.0));
4502 int32_t h2=int32_t(h*((double)sdci[7]/10000.0));
4503 x1=x1-((w2-w)/2);
4504 x2=x2+((w2-w)/2);
4505 y1=y1-((h2-h)/2);
4506 y2=y2+((h2-h)/2);
4507 }
4508
4509 int32_t color=sdci[6]/10000;
4510
4511 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4512
4513 if(sdci[11]/10000<=127) //translucent
4514 {
4515 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4516 }
4517
4518 if(sdci[10]!=0) //rotation
4519 {
4520 int32_t xy[4];
4521 int32_t rx=sdci[8]/10000;
4522 int32_t ry=sdci[9]/10000;
4523 fixed ra1=itofix(sdci[10]%10000)/10000;
4524 fixed ra2=itofix(sdci[10]/10000);
4525 fixed ra=ra1+ra2;
4526
4527 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4528 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4529 xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
4530 xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
4531 x1=xy[0];
4532 y1=xy[1];
4533 x2=xy[2];
4534 y2=xy[3];
4535 }
4536
4537 line(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4538 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4539 }
4540
4541
4542 void bmp_do_spliner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4543 {
4544 /* layer, x1, y1, x2, y2, x3, y3, x4, y4, color, opacity */
4545 //sdci[17] Bitmap Pointer
4546
4547 int32_t points[8] = { xoffset + (sdci[2]/10000), yoffset + (sdci[3]/10000),
4548 xoffset + (sdci[4]/10000), yoffset + (sdci[5]/10000),
4549 xoffset + (sdci[6]/10000), yoffset + (sdci[7]/10000),
4550 xoffset + (sdci[8]/10000), yoffset + (sdci[9]/10000)
4551 };
4552
4553 if(sdci[11]/10000 < 128) //translucent
4554 {
4555 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4556 }
4557
4558 if ( sdci[17] <= 0 )
4559 {
4560 Z_scripterrlog("bitmap->Spline() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4561 return;
4562 }
4563
4564 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4565 if ( refbmp == NULL ) return;
4566
4567 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4568
4569 spline(refbmp, points, sdci[10]/10000);
4570
4571 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4572 }
4573
4574
4575 void bmp_do_putpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4576 {
4577 //sdci[1]=layer
4578 //sdci[2]=x
4579 //sdci[3]=y
4580 //sdci[4]=color
4581 //sdci[5]=rotation anchor x
4582 //sdci[6]=rotation anchor y
4583 //sdci[7]=rotation angle
4584 //sdci[8]=opacity
4585 //sdci[17] Bitmap Pointer
4586 int32_t x1=sdci[2]/10000;
4587 int32_t y1=sdci[3]/10000;
4588 int32_t color=sdci[4]/10000;
4589
4590 if(sdci[8]/10000<=127) //translucent
4591 {
4592 drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4593 }
4594
4595 if ( sdci[17] <= 0 )
4596 {
4597 Z_scripterrlog("bitmap->PutPixel() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4598 return;
4599 }
4600
4601 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4602 if ( refbmp == NULL ) return;
4603
4604 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4605
4606 if(sdci[7]!=0) //rotation
4607 {
4608 int32_t xy[2];
4609 int32_t rx=sdci[5]/10000;
4610 int32_t ry=sdci[6]/10000;
4611 fixed ra1=itofix(sdci[7]%10000)/10000;
4612 fixed ra2=itofix(sdci[7]/10000);
4613 fixed ra=ra1+ra2;
4614
4615 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4616 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4617 x1=xy[0];
4618 y1=xy[1];
4619 }
4620
4621 putpixel(refbmp, x1+xoffset, y1+yoffset, color);
4622 drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4623 }
4624
4625
4626 void bmp_do_drawtiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4627 {
4628 //sdci[1]=layer
4629 //sdci[2]=x
4630 //sdci[3]=y
4631 //sdci[4]=tile
4632 //sdci[5]=tile width
4633 //sdci[6]=tile height
4634 //sdci[7]=color (cset)
4635 //sdci[8]=scale x
4636 //sdci[9]=scale y
4637 //sdci[10]=rotation anchor x
4638 //sdci[11]=rotation anchor y
4639 //sdci[12]=rotation angle
4640 //sdci[13]=flip
4641 //sdci[14]=transparency
4642 //sdci[15]=opacity
4643 //sdci[17] Bitmap Pointer
4644
4645 int32_t w = sdci[5]/10000;
4646 int32_t h = sdci[6]/10000;
4647
4648 if(w < 1 || h < 1 || h > 20 || w > 20)
4649 {
4650 return;
4651 }
4652
4653 if ( sdci[17] <= 0 )
4654 {
4655 Z_scripterrlog("bitmap->DrawTile() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4656 return;
4657 }
4658
4659 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4660 if ( refbmp == NULL ) return;
4661
4662 int32_t xscale=sdci[8]/10000;
4663 int32_t yscale=sdci[9]/10000;
4664 int32_t rx = sdci[10]/10000;
4665 int32_t ry = sdci[11]/10000;
4666 float rotation=sdci[12]/10000;
4667 int32_t flip=(sdci[13]/10000)&3;
4668 bool transparency=sdci[14]!=0;
4669 int32_t opacity=sdci[15]/10000;
4670 int32_t color=sdci[7]/10000;
4671
4672 int32_t x1=sdci[2]/10000;
4673 int32_t y1=sdci[3]/10000;
4674
4675
4676 //don't scale if it's not safe to do so
4677 bool canscale = true;
4678
4679 if(xscale==0||yscale==0)
4680 {
4681 return;
4682 }
4683
4684 if(xscale<0||yscale<0)
4685 canscale = false; //default size
4686
4687 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4688
4689 if((xscale>0 && yscale>0) || rotation) //scaled or rotated
4690 {
4691 BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16);
4692
4693 if(transparency) //transparency
4694 {
4695 TileHelper::OverTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
4696 }
4697 else //no transparency
4698 {
4699 TileHelper::OldPutTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
4700 }
4701
4702 if(rotation != 0)
4703 {
4704 //low negative values indicate no anchor-point rotation
4705 if(rx>-777||ry>-777)
4706 {
4707 int32_t xy[2];
4708 fixed ra1=itofix(sdci[12]%10000)/10000;
4709 fixed ra2=itofix(sdci[12]/10000);
4710 fixed ra=ra1+ra2;
4711 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4712 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4713 x1=xy[0];
4714 y1=xy[1];
4715 }
4716
4717 if(canscale) //scale first
4718 {
4719 //damnit all, .. fixme.
4720 BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
4721 clear_bitmap(tempbit);
4722
4723 stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
4724
4725 if(opacity < 128)
4726 {
4727 clear_bitmap(prim_bmp);
4728 rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
4729 draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
4730 }
4731 else
4732 {
4733 rotate_sprite(refbmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4734 }
4735
4736 destroy_bitmap(tempbit);
4737 }
4738 else //no scale
4739 {
4740 if(opacity < 128)
4741 {
4742 clear_bitmap(prim_bmp);
4743 rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
4744 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4745 }
4746 else
4747 {
4748 rotate_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4749 }
4750 }
4751 }
4752 else //scale only
4753 {
4754 if(canscale)
4755 {
4756 if(opacity<128)
4757 {
4758 clear_bitmap(prim_bmp);
4759 stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
4760 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4761 }
4762 else
4763 {
4764 stretch_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
4765 }
4766 }
4767 else //error -do not scale
4768 {
4769 if(opacity<128)
4770 {
4771 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4772 }
4773 else
4774 {
4775 draw_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset);
4776 }
4777 }
4778 }
4779
4780 script_drawing_commands.ReleaseSubBitmap(pbitty);
4781
4782 }
4783 else // no scale or rotation
4784 {
4785 if(transparency)
4786 {
4787 if(opacity<=127)
4788 TileHelper::OverTileTranslucent(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
4789 else
4790 TileHelper::OverTile(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
4791 }
4792 else
4793 {
4794 if(opacity<=127)
4795 TileHelper::PutTileTranslucent(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
4796 else
4797 TileHelper::OldPutTile(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
4798 }
4799 }
4800 }
4801
4802 void bmp_do_drawtilecloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4803 {
4804 //sdci[1]=layer
4805 //sdci[2]=x
4806 //sdci[3]=y
4807 //sdci[4]=tile
4808 //sdci[5]=tile width
4809 //sdci[6]=tile height
4810 //sdci[7]=flip
4811 //sdci[17] Bitmap Pointer
4812
4813 int32_t w = sdci[5]/10000;
4814 int32_t h = sdci[6]/10000;
4815
4816 if(w < 1 || h < 1 || h > 20 || w > 20)
4817 {
4818 return;
4819 }
4820
4821 if ( sdci[17] <= 0 )
4822 {
4823 Z_scripterrlog("bitmap->DrawTileCloaked() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4824 return;
4825 }
4826
4827 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4828 if ( refbmp == NULL ) return;
4829
4830 int32_t flip=(sdci[7]/10000)&3;
4831
4832 int32_t x1=sdci[2]/10000;
4833 int32_t y1=sdci[3]/10000;
4834
4835 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4836
4837 TileHelper::OverTileCloaked(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, flip);
4838 }
4839
4840
4841 void bmp_do_drawcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4842 {
4843 //sdci[1]=layer
4844 //sdci[2]=x
4845 //sdci[3]=y
4846 //sdci[4]=combo
4847 //sdci[5]=tile width
4848 //sdci[6]=tile height
4849 //sdci[7]=color (cset)
4850 //sdci[8]=scale x
4851 //sdci[9]=scale y
4852 //sdci[10]=rotation anchor x
4853 //sdci[11]=rotation anchor y
4854 //sdci[12]=rotation angle
4855 //sdci[13]=frame
4856 //sdci[14]=flip
4857 //sdci[15]=transparency
4858 //sdci[16]=opacity
4859 //sdci[17] Bitmap Pointer
4860 int32_t w = sdci[5]/10000;
4861 int32_t h = sdci[6]/10000;
4862
4863 if(w<1||h<1||h>20||w>20)
4864 {
4865 return;
4866 }
4867
4868 if ( sdci[17] <= 0 )
4869 {
4870 Z_scripterrlog("bitmap->DrawCombo() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4871 return;
4872 }
4873
4874 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4875 if ( refbmp == NULL ) return;
4876 int32_t cmb = (sdci[4]/10000);
4877 if((unsigned)cmb >= MAXCOMBOS)
4878 {
4879 Z_scripterrlog("DrawCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
4880 return;
4881 }
4882
4883 int32_t xscale=sdci[8]/10000;
4884 int32_t yscale=sdci[9]/10000;
4885 int32_t rx = sdci[10]/10000; //these work now
4886 int32_t ry = sdci[11]/10000; //these work now
4887 float rotation=sdci[12]/10000;
4888
4889 bool transparency=sdci[15]!=0;
4890 int32_t opacity=sdci[16]/10000;
4891 int32_t color=sdci[7]/10000;
4892 int32_t x1=sdci[2]/10000;
4893 int32_t y1=sdci[3]/10000;
4894
4895 const newcombo & c = combobuf[cmb];
4896 int32_t tiletodraw = combo_tile(c, x1, y1);
4897 int32_t flip = ((sdci[14]/10000) & 3) ^ c.flip;
4898 int32_t skiprows=c.skipanimy;
4899
4900
4901 //don't scale if it's not safe to do so
4902 bool canscale = true;
4903
4904 if(xscale==0||yscale==0)
4905 {
4906 return;
4907 }
4908
4909 if(xscale<0||yscale<0)
4910 canscale = false; //default size
4911
4912 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4913
4914 if((xscale>0 && yscale>0) || rotation) //scaled or rotated
4915 {
4916 BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16); //-pbitty in the hisouse. :D
4917
4918 if(transparency)
4919 {
4920 TileHelper::OverTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
4921 }
4922 else //no transparency
4923 {
4924 TileHelper::OldPutTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
4925 }
4926
4927 if(rotation != 0) // rotate
4928 {
4929 //fixed point sucks ;0
4930 if(rx>-777||ry>-777) //set the rotation anchor and rotate around that
4931 {
4932 int32_t xy[2];
4933 fixed ra1=itofix(sdci[12]%10000)/10000;
4934 fixed ra2=itofix(sdci[12]/10000);
4935 fixed ra=ra1+ra2;
4936 xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4937 xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4938 x1=xy[0];
4939 y1=xy[1];
4940 }
4941
4942 if(canscale) //scale first
4943 {
4944 BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
4945 clear_bitmap(tempbit);
4946
4947 stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
4948
4949 if(opacity < 128)
4950 {
4951 clear_bitmap(prim_bmp);
4952 rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
4953 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4954 }
4955 else
4956 {
4957 rotate_sprite(refbmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4958 }
4959
4960 destroy_bitmap(tempbit);
4961 }
4962 else //no scale
4963 {
4964 if(opacity < 128)
4965 {
4966 clear_bitmap(prim_bmp);
4967 rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
4968 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4969 }
4970 else
4971 {
4972 rotate_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4973 }
4974 }
4975 }
4976 else //scale only
4977 {
4978 if(canscale)
4979 {
4980 if(opacity<128)
4981 {
4982 clear_bitmap(prim_bmp);
4983 stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
4984 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4985 }
4986 else
4987 {
4988 stretch_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
4989 }
4990 }
4991 else //error -do not scale
4992 {
4993 if(opacity<128)
4994 {
4995 draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4996 }
4997 else
4998 {
4999 draw_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset);
5000 }
5001 }
5002 }
5003
5004 script_drawing_commands.ReleaseSubBitmap(pbitty); //rap sucks
5005 }
5006 else // no scale or rotation
5007 {
5008 if(transparency)
5009 {
5010 if(opacity<=127)
5011 TileHelper::OverTileTranslucent(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
5012 else
5013 TileHelper::OverTile(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
5014 }
5015 else
5016 {
5017 if(opacity<=127)
5018 TileHelper::PutTileTranslucent(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
5019 else
5020 TileHelper::OldPutTile(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
5021 }
5022 }
5023 }
5024
5025
5026 void bmp_do_drawcombocloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5027 {
5028 //sdci[1]=layer
5029 //sdci[2]=x
5030 //sdci[3]=y
5031 //sdci[4]=combo
5032 //sdci[5]=tile width
5033 //sdci[6]=tile height
5034 //sdci[7]=flip
5035 //sdci[17] Bitmap Pointer
5036
5037 int32_t w = sdci[5]/10000;
5038 int32_t h = sdci[6]/10000;
5039
5040 if(w<1||h<1||h>20||w>20)
5041 {
5042 return;
5043 }
5044
5045 if ( sdci[17] <= 0 )
5046 {
5047 Z_scripterrlog("bitmap->DrawComboCloaked() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5048 return;
5049 }
5050
5051 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5052 if ( refbmp == NULL ) return;
5053 int32_t cmb = (sdci[4]/10000);
5054 if((unsigned)cmb >= MAXCOMBOS)
5055 {
5056 Z_scripterrlog("DrawComboCloaked() cannot draw combo '%d', as it is out of bounds.\n", cmb);
5057 return;
5058 }
5059
5060 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5061
5062 int32_t x1=sdci[2]/10000;
5063 int32_t y1=sdci[3]/10000;
5064
5065 const newcombo & c = combobuf[cmb];
5066 int32_t tiletodraw = combo_tile(c, x1, y1);
5067 int32_t flip = ((sdci[7]/10000) & 3) ^ c.flip;
5068 int32_t skiprows=c.skipanimy;
5069
5070 TileHelper::OverTileCloaked(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, flip, skiprows);
5071 }
5072
5073
5074 void bmp_do_fasttiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5075 {
5076 /* layer, x, y, tile, color opacity */
5077 //sdci[17] Bitmap Pointer
5078
5079 int32_t opacity = sdci[6]/10000;
5080 if ( sdci[17] <= 0 )
5081 {
5082 Z_scripterrlog("bitmap->FastTile() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5083 return;
5084 }
5085 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5086 if ( refbmp == NULL ) return;
5087
5088 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5089
5090 if(opacity < 128)
5091 overtiletranslucent16(refbmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0, opacity);
5092 else
5093 overtile16(refbmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0);
5094 }
5095
5096 void do_bmpwritetile(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5097 {
5098 /* layer, x, y, tile, is8bit, mask */
5099 //sdci[17] Bitmap Pointer
5100 if ( sdci[17] <= 0 )
5101 {
5102 Z_scripterrlog("bitmap->WriteTile() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5103 return;
5104 }
5105 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5106 if ( refbmp == NULL ) return;
5107
5108 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5109
5110 int32_t x = (sdci[2]/10000), y = (sdci[3]/10000), tl = (sdci[4]/10000);
5111 bool is8bit = sdci[5]!=0, mask = sdci[6]!=0;
5112
5113 write_tile(newtilebuf, refbmp, tl, x+xoffset, y+yoffset, is8bit, mask);
5114 }
5115
5116 void do_bmpdither(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5117 {
5118 /* layer, mask, color, ditherType, ditherArg */
5119 //sdci[2] Mask Bitmap Pointer
5120 //sdci[3] Color
5121 //sdci[17] Bitmap Pointer
5122 if ( sdci[17] <= 0 )
5123 {
5124 Z_scripterrlog("bitmap->Dither() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5125 return;
5126 }
5127 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5128 if ( refbmp == NULL ) return;
5129 if ( sdci[2] <= 0 )
5130 {
5131 Z_scripterrlog("bitmap->Dither() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[2]);
5132 return;
5133 }
5134 BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5135 if ( mask == NULL ) return;
5136
5137 int32_t dType = sdci[4] / 10000L;
5138 if(dType < 0 || dType >= dithMax)
5139 {
5140 Z_scripterrlog("bitmap->Dither() used an invalid dither type: %d. Aborting.\n", dType);
5141 return;
5142 }
5143
5144 ditherblit(refbmp, mask, byte(sdci[3]/10000L), dType, sdci[5]/10000L);
5145 }
5146
5147 void do_bmpreplcol(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5148 {
5149 /* layer, shift, startcol, endcol */
5150 //sdci[2] NewCol
5151 //sdci[3] StartCol
5152 //sdci[4] EndCol
5153 //sdci[17] Bitmap Pointer
5154 if ( sdci[17] <= 0 )
5155 {
5156 Z_scripterrlog("bitmap->ReplaceColors() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5157 return;
5158 }
5159 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5160 if ( refbmp == NULL ) return;
5161 replColor(refbmp, sdci[2]/10000L, sdci[3]/10000L, sdci[4]/10000L, false);
5162 }
5163
5164 void do_bmpshiftcol(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5165 {
5166 /* layer, shift, startcol, endcol */
5167 //sdci[2] ShiftAmount
5168 //sdci[3] StartCol
5169 //sdci[4] EndCol
5170 //sdci[17] Bitmap Pointer
5171 if ( sdci[17] <= 0 )
5172 {
5173 Z_scripterrlog("bitmap->ShiftColors() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5174 return;
5175 }
5176 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5177 if ( refbmp == NULL ) return;
5178 replColor(refbmp, sdci[2]/10000L, sdci[3]/10000L, sdci[4]/10000L, true);
5179 }
5180
5181 void do_bmpmaskdraw(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5182 {
5183 /* layer, mask, color */
5184 //sdci[2] Mask Bitmap Pointer
5185 //sdci[3] Color
5186 //sdci[4] start mask color
5187 //sdci[5] end mask color
5188 //sdci[17] Bitmap Pointer
5189 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5190 if ( refbmp == NULL )
5191 {
5192 Z_scripterrlog("bitmap->MaskDraw() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5193 return;
5194 }
5195 BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5196 if ( mask == NULL )
5197 {
5198 Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[2]);
5199 return;
5200 }
5201 auto fillcol = sdci[3]/10000L;
5202 if(unsigned(fillcol) > 0xFF) return; //invalid color, nothing to draw
5203 auto startcol = vbound(sdci[4]/10000L,0x00,0xFF);
5204 auto endcol = vbound(sdci[5]/10000L,0x00,0xFF);
5205 mask_colorfill(refbmp, mask, fillcol, startcol, endcol);
5206 }
5207
5208 void do_bmpmaskblit(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5209 {
5210 /* layer, mask, color */
5211 //sdci[2] Mask Bitmap Pointer
5212 //sdci[3] Pattern Bitmap
5213 //sdci[4] bool 'pattern repeats'
5214 //sdci[5] start mask color
5215 //sdci[6] end mask color
5216 //sdci[17] Bitmap Pointer
5217 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5218 if ( refbmp == NULL )
5219 {
5220 Z_scripterrlog("bitmap->MaskDraw() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5221 return;
5222 }
5223 BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5224 if ( mask == NULL )
5225 {
5226 Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap (mask) id: %d. Aborting.\n", sdci[2]);
5227 return;
5228 }
5229 BITMAP *pattern = FFCore.GetScriptBitmap(sdci[3]-10);
5230 if ( pattern == NULL )
5231 {
5232 Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap (pattern) id: %d. Aborting.\n", sdci[3]);
5233 return;
5234 }
5235 bool repeats = sdci[4]!=0;
5236 auto startcol = vbound(sdci[5]/10000L,0x00,0xFF);
5237 auto endcol = vbound(sdci[6]/10000L,0x00,0xFF);
5238 mask_blit(refbmp, mask, pattern, repeats, startcol, endcol);
5239 }
5240
5241 void bmp_do_fastcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5242 {
5243 /* layer, x, y, tile, color opacity */
5244 //sdci[17] Bitmap Pointer
5245 int32_t opacity = sdci[6] / 10000;
5246 int32_t x1 = sdci[2] / 10000;
5247 int32_t y1 = sdci[3] / 10000;
5248 int32_t index = sdci[4]/10000;
5249 if ( sdci[17] <= 0 )
5250 {
5251 Z_scripterrlog("bitmap->FastCombo() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5252 return;
5253 }
5254 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5255 if ( refbmp == NULL ) return;
5256 int32_t cmb = (sdci[4]/10000);
5257 if((unsigned)cmb >= MAXCOMBOS)
5258 {
5259 Z_scripterrlog("FastCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
5260 return;
5261 }
5262
5263 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5264
5265 //if( index >= MAXCOMBOS ) return; //bleh.
5266 /*
5267 const newcombo & c = combobuf[index];
5268
5269 if(opacity < 128)
5270 overtiletranslucent16(refbmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip, opacity);
5271 else
5272 overtile16(refbmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip);
5273 */
5274
5275 if(opacity < 128)
5276 {
5277 //void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
5278 overcomboblocktranslucent(refbmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1, 128);
5279
5280 }
5281 else
5282 {
5283 //overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
5284 overcomboblock(refbmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1);
5285 }
5286 }
5287
5288
5289
5290 void bmp_do_drawcharr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5291 {
5292 //sdci[17] Bitmap Pointer
5293 if ( sdci[17] <= 0 )
5294 {
5295 Z_scripterrlog("bitmap->DrawCharacter() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5296 return;
5297 }
5298 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5299 if ( refbmp == NULL ) return;
5300
5301 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5302
5303 //broken 2.50.2 and earlier drawcharacter()
5304 if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
5305 {
5306 //sdci[1]=layer
5307 //sdci[2]=x
5308 //sdci[3]=y
5309 //sdci[4]=font
5310 //sdci[5]=color
5311 //sdci[6]=bg color
5312 //sdci[7]=strech x (width)
5313 //sdci[8]=stretch y (height)
5314 //sdci[9]=char
5315 //sdci[10]=opacity
5316 //sdci[17] Bitmap Pointer
5317
5318 int32_t x=sdci[2]/10000;
5319 int32_t y=sdci[3]/10000;
5320 int32_t font_index=sdci[4]/10000;
5321 int32_t color=sdci[5]/10000;
5322 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5323 int32_t w=sdci[7]/10000;
5324 int32_t h=sdci[8]/10000;
5325 char glyph=char(sdci[9]/10000);
5326 int32_t opacity=sdci[10]/10000;
5327
5328 //safe check
5329 if(bg_color < -1) bg_color = -1;
5330
5331 if(w>512) w=512; //w=vbound(w,0,512);
5332
5333 if(h>512) h=512; //h=vbound(h,0,512);
5334
5335 //undone
5336 if(w>0&&h>0)//stretch the character
5337 {
5338 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5339
5340 if(opacity < 128)
5341 {
5342 if(w>128||h>128)
5343 {
5344 clear_bitmap(prim_bmp);
5345
5346 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5347 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5348 draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5349 }
5350 else //this is faster
5351 {
5352 BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
5353
5354 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5355 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5356 draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5357
5358 script_drawing_commands.ReleaseSubBitmap(pbmp2);
5359 }
5360 }
5361 else // no opacity
5362 {
5363 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5364 stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5365 }
5366
5367 }
5368 else //no stretch
5369 {
5370 if(opacity < 128)
5371 {
5372 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5373 clear_bitmap(pbmp);
5374
5375 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5376 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5377
5378 destroy_bitmap(pbmp);
5379 }
5380 else // no opacity
5381 {
5382 textprintf_ex(refbmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
5383 }
5384 }
5385 }
5386
5387 else //2.53.0 fixed version and later.
5388 {
5389
5390 //sdci[1]=layer
5391 //sdci[2]=x
5392 //sdci[3]=y
5393 //sdci[4]=font
5394 //sdci[5]=color
5395 //sdci[6]=bg color
5396 //sdci[7]=strech x (width)
5397 //sdci[8]=stretch y (height)
5398 //sdci[9]=char
5399 //sdci[10]=opacity
5400
5401 int32_t x=sdci[2]/10000;
5402 int32_t y=sdci[3]/10000;
5403 int32_t font_index=sdci[4]/10000;
5404 int32_t color=sdci[5]/10000;
5405 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5406 int32_t w=sdci[7]/10000;
5407 int32_t h=sdci[8]/10000;
5408 char glyph=char(sdci[9]/10000);
5409 int32_t opacity=sdci[10]/10000;
5410
5411 //safe check
5412 if(bg_color < -1) bg_color = -1;
5413
5414 if(w>512) w=512; //w=vbound(w,0,512);
5415
5416 if(h>512) h=512; //h=vbound(h,0,512);
5417
5418 //undone
5419 if(w>0&&h>0)//stretch the character
5420 {
5421 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5422
5423 if(opacity < 128)
5424 {
5425 if(w>128||h>128)
5426 {
5427 clear_bitmap(prim_bmp);
5428
5429 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5430 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5431 draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5432 }
5433 else //this is faster
5434 {
5435 BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
5436
5437 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5438 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5439 draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5440
5441 script_drawing_commands.ReleaseSubBitmap(pbmp2);
5442 }
5443 }
5444 else // no opacity
5445 {
5446 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5447 stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5448 }
5449
5450 }
5451 else //no stretch
5452 {
5453 if(opacity < 128)
5454 {
5455 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5456 clear_bitmap(pbmp);
5457
5458 textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5459 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5460
5461 destroy_bitmap(pbmp);
5462 }
5463 else // no opacity
5464 {
5465 textprintf_ex(refbmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
5466 }
5467 }
5468
5469 }
5470
5471 }
5472
5473
5474 void bmp_do_drawintr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5475 {
5476 if ( sdci[17] <= 0 )
5477 {
5478 Z_scripterrlog("bitmap->DrawInteger() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5479 return;
5480 }
5481 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5482 if ( refbmp == NULL ) return;
5483
5484 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5485
5486 //broken 2.50.2 and earlier drawinteger()
5487 if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
5488 {
5489 //sdci[1]=layer
5490 //sdci[2]=x
5491 //sdci[3]=y
5492 //sdci[4]=font
5493 //sdci[5]=color
5494 //sdci[6]=bg color
5495 //sdci[7]=strech x (width)
5496 //sdci[8]=stretch y (height)
5497 //sdci[9]=integer
5498 //sdci[10]=num decimal places
5499 //sdci[11]=opacity
5500 //sdci[17] Bitmap Pointer
5501
5502 int32_t x=sdci[2]/10000;
5503 int32_t y=sdci[3]/10000;
5504 int32_t font_index=sdci[4]/10000;
5505 int32_t color=sdci[5]/10000;
5506 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5507 int32_t w=sdci[7]/10000;
5508 int32_t h=sdci[8]/10000;
5509 //float number=static_cast<float>(sdci[9])/10000.0f;
5510 int32_t decplace=sdci[10]/10000;
5511 int32_t opacity=sdci[11]/10000;
5512
5513 //safe check
5514 if(bg_color < -1) bg_color = -1;
5515
5516 if(w>512) w=512; //w=vbound(w,0,512);
5517
5518 if(h>512) h=512; //h=vbound(h,0,512);
5519
5520 char numbuf[15];
5521
5522 switch(decplace)
5523 {
5524 default:
5525 case 0:
5526 sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
5527 break; //reducing the value by -1, so 8.000 printed as '7'. -Z
5528
5529 case 1:
5530 //sprintf(numbuf,"%.01f",number);
5531 sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
5532 break;
5533
5534 case 2:
5535 //sprintf(numbuf,"%.02f",number);
5536 sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
5537 break;
5538
5539 case 3:
5540 //sprintf(numbuf,"%.03f",number);
5541 sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
5542 break;
5543
5544 case 4:
5545 //sprintf(numbuf,"%.04f",number);
5546 sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
5547 break;
5548 }
5549
5550 if(w>0&&h>0)//stretch
5551 {
5552 BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5553
5554 if(opacity < 128)
5555 {
5556 if(w>128||h>128)
5557 {
5558 clear_bitmap(prim_bmp);
5559
5560 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5561 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5562 draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5563 }
5564 else
5565 {
5566 BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
5567 clear_bitmap(pbmp2);
5568
5569 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5570 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5571 draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5572
5573 destroy_bitmap(pbmp2);
5574 }
5575 }
5576 else // no opacity
5577 {
5578 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5579 stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5580 }
5581
5582 }
5583 else //no stretch
5584 {
5585 if(opacity < 128)
5586 {
5587 BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5588 clear_bitmap(pbmp);
5589
5590 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5591 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5592
5593 destroy_bitmap(pbmp);
5594 }
5595 else // no opacity
5596 {
5597 textout_ex(refbmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
5598 }
5599 }
5600
5601 }
5602
5603 else //2.53.0 fixed version and later.
5604 {
5605 //sdci[1]=layer
5606 //sdci[2]=x
5607 //sdci[3]=y
5608 //sdci[4]=font
5609 //sdci[5]=color
5610 //sdci[6]=bg color
5611 //sdci[7]=strech x (width)
5612 //sdci[8]=stretch y (height)
5613 //sdci[9]=integer
5614 //sdci[10]=num decimal places
5615 //sdci[11]=opacity
5616
5617 int32_t x=sdci[2]/10000;
5618 int32_t y=sdci[3]/10000;
5619 int32_t font_index=sdci[4]/10000;
5620 int32_t color=sdci[5]/10000;
5621 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5622 int32_t w=sdci[7]/10000;
5623 int32_t h=sdci[8]/10000;
5624 //float number=static_cast<float>(sdci[9])/10000.0f;
5625 //int32_t numberint = sdci[9]/10000;
5626 int32_t decplace=sdci[10]/10000;
5627 int32_t opacity=sdci[11]/10000;
5628
5629 //safe check
5630 if(bg_color < -1) bg_color = -1;
5631
5632 if(w>512) w=512; //w=vbound(w,0,512);
5633
5634 if(h>512) h=512; //h=vbound(h,0,512);
5635
5636 char numbuf[15];
5637
5638 switch(decplace)
5639 {
5640 default:
5641 case 0:
5642 sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
5643 break; //reducing the value by -1, so 8.000 printed as '7'. -Z
5644
5645 case 1:
5646 //sprintf(numbuf,"%.01f",number);
5647 sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
5648 break;
5649
5650 case 2:
5651 //sprintf(numbuf,"%.02f",number);
5652 sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
5653 break;
5654
5655 case 3:
5656 //sprintf(numbuf,"%.03f",number);
5657 sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
5658 break;
5659
5660 case 4:
5661 //sprintf(numbuf,"%.04f",number);
5662 sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
5663 break;
5664 }
5665
5666 //FONT* font=get_zc_font(sdci[4]/10000);
5667
5668 if(w>0&&h>0)//stretch
5669 {
5670 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(get_zc_font(font_index), numbuf)+1, text_height(get_zc_font(font_index)));
5671 clear_bitmap(pbmp);
5672 //script_drawing_commands.GetSmallTextureBitmap(1,1);
5673
5674 if(opacity < 128)
5675 {
5676 if(w>128||h>128)
5677 {
5678 clear_bitmap(prim_bmp);
5679
5680 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5681 stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5682 draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5683 }
5684 else
5685 {
5686 BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
5687 clear_bitmap(pbmp2);
5688
5689 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5690 stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5691 draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5692
5693 destroy_bitmap(pbmp2);
5694 }
5695 }
5696 else // no opacity
5697 {
5698 textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5699 stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5700 }
5701
5702 }
5703 else //no stretch
5704 {
5705 if(opacity < 128)
5706 {
5707 FONT* font = get_zc_font(font_index);
5708 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(font, numbuf), text_height(font));
5709 clear_bitmap(pbmp);
5710
5711 textout_ex(pbmp, font, numbuf, 0, 0, color, bg_color);
5712 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5713
5714 destroy_bitmap(pbmp);
5715 }
5716 else // no opacity
5717 {
5718 textout_ex(refbmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
5719 }
5720 }
5721 }
5722 }
5723
5724
5725 void bmp_do_drawstringr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5726 {
5727 //sdci[1]=layer
5728 //sdci[2]=x
5729 //sdci[3]=y
5730 //sdci[4]=font
5731 //sdci[5]=color
5732 //sdci[6]=bg color
5733 //sdci[7]=format_option
5734 //sdci[8]=string
5735 //sdci[9]=opacity
5736 //sdci[17] Bitmap Pointer
5737 if ( sdci[17] <= 0 )
5738 {
5739 Z_scripterrlog("bitmap->DrawString() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5740 return;
5741 }
5742
5743 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5744 if ( refbmp == NULL ) return;
5745
5746 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5747
5748 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5749
5750 if(!str)
5751 {
5752 al_trace("String pointer is null! Internal error. \n");
5753 return;
5754 }
5755
5756 int32_t x=sdci[2]/10000;
5757 int32_t y=sdci[3]/10000;
5758 FONT* font=get_zc_font(sdci[4]/10000);
5759 int32_t color=sdci[5]/10000;
5760 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5761 int32_t format_type=sdci[7]/10000;
5762 int32_t opacity=sdci[9]/10000;
5763 //sdci[8] not needed :)
5764
5765 //safe check
5766 if(bg_color < -1) bg_color = -1;
5767
5768 if(opacity < 128)
5769 {
5770 int32_t width=zc_min(text_length(font, str->c_str()), 512);
5771 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
5772 clear_bitmap(pbmp);
5773 textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
5774 if(format_type == 2) // right-sided text
5775 x-=width;
5776 else if(format_type == 1) // centered text
5777 x-=width/2;
5778 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5779 destroy_bitmap(pbmp);
5780 }
5781 else // no opacity
5782 {
5783 if(format_type == 2) // right-sided text
5784 {
5785 textout_right_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5786 }
5787 else if(format_type == 1) // centered text
5788 {
5789 textout_centre_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5790 }
5791 else // standard left-sided text
5792 {
5793 textout_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5794 }
5795 }
5796 }
5797
5798 void bmp_do_drawstringr2(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5799 {
5800 //sdci[1]=layer
5801 //sdci[2]=x
5802 //sdci[3]=y
5803 //sdci[4]=font
5804 //sdci[5]=color
5805 //sdci[6]=bg color
5806 //sdci[7]=format_option
5807 //sdci[8]=string
5808 //sdci[9]=opacity
5809 //sdci[10]=shadowtype
5810 //sdci[11]=shadow_color
5811 //sdci[17] Bitmap Pointer
5812 if ( sdci[17] <= 0 )
5813 {
5814 Z_scripterrlog("bitmap->DrawString() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5815 return;
5816 }
5817
5818 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5819 if ( refbmp == NULL ) return;
5820
5821 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5822
5823 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5824
5825 if(!str)
5826 {
5827 al_trace("String pointer is null! Internal error. \n");
5828 return;
5829 }
5830
5831 int32_t x=sdci[2]/10000;
5832 int32_t y=sdci[3]/10000;
5833 FONT* font=get_zc_font(sdci[4]/10000);
5834 int32_t color=sdci[5]/10000;
5835 int32_t bg_color=sdci[6]/10000; //-1 = transparent
5836 int32_t format_type=sdci[7]/10000;
5837 int32_t opacity=sdci[9]/10000;
5838 int32_t textstyle = sdci[10]/10000;
5839 int32_t shadow_color = sdci[11]/10000;
5840 //sdci[8] not needed :)
5841
5842 //safe check
5843 if(bg_color < -1) bg_color = -1;
5844
5845 if(opacity < 128)
5846 {
5847 int32_t width=zc_min(text_length(font, str->c_str()), 512);
5848 BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
5849 clear_bitmap(pbmp);
5850 textout_styled_aligned_ex(pbmp, font, str->c_str(), 0, 0, textstyle, sstaLEFT, color, shadow_color, bg_color);
5851 if(format_type == 2) // right-sided text
5852 x-=width;
5853 else if(format_type == 1) // centered text
5854 x-=width/2;
5855 draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5856 destroy_bitmap(pbmp);
5857 }
5858 else // no opacity
5859 {
5860 textout_styled_aligned_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, textstyle, format_type, color, shadow_color, bg_color);
5861 }
5862 }
5863
5864 void bmp_do_clearr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5865 {
5866 //sdci[1]=layer
5867 //sdci[17] Bitmap Pointer
5868 //Z_scripterrlog("bitmap->Clear() pointer is: %d\n", sdci[17]);
5869 if ( sdci[17] <= 0 )
5870 {
5871 Z_scripterrlog("bitmap->Clear() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5872 return;
5873 }
5874 int32_t bitid = sdci[17] - 10;
5875 if ( scb.script_created_bitmaps[bitid].u_bmp )
5876 clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5877 }
5878
5879 void bmp_do_clearcolorr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5880 {
5881 //sdci[1]=layer
5882 //sdci[2]=color
5883 //sdci[17] Bitmap Pointer
5884 int32_t pal_color = sdci[2]/10000;
5885 if ( sdci[17] <= 0 )
5886 {
5887 Z_scripterrlog("bitmap->ClearToColor() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5888 return;
5889 }
5890 int32_t bitid = sdci[17] - 10;
5891 if ( scb.script_created_bitmaps[bitid].u_bmp )
5892 clear_to_color(scb.script_created_bitmaps[bitid].u_bmp, pal_color);
5893 }
5894
5895
5896 void bmp_do_regenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5897 {
5898 //sdci[1]=layer
5899 int32_t h = sdci[3]/10000;
5900 int32_t w = sdci[2]/10000;
5901 if ( get_bit(quest_rules, qr_OLDCREATEBITMAP_ARGS) )
5902 {
5903 //flip height and width
5904 h = h ^ w;
5905 w = h ^ w;
5906 h = h ^ w;
5907 }
5908 //sdci[17] Bitmap Pointer
5909 //Z_scripterrlog("bitmap->Create() pointer is: %d\n", sdci[17]);
5910 if ( sdci[17] <= 0 )
5911 {
5912 Z_scripterrlog("bitmap->Create() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5913 return;
5914 }
5915 int32_t bitid = sdci[17] - 10;
5916 if ( scb.script_created_bitmaps[bitid].u_bmp )
5917 destroy_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5918 scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,w,h);
5919
5920 scb.script_created_bitmaps[bitid].width = w;
5921 scb.script_created_bitmaps[bitid].height = h;
5922
5923
5924
5925 }
5926
5927 void bmp_do_readr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5928 {
5929 //sdci[1]=layer
5930 //sdci[2]=filename
5931 //sdci[3]=y
5932 //sdci[4]=font
5933 //sdci[5]=color
5934 //sdci[6]=bg color
5935 //sdci[7]=format_option
5936 //sdci[8]=string
5937 //sdci[9]=opacity
5938 //sdci[17] Bitmap Pointer
5939 //Z_scripterrlog("bitmap->Read() pointer is: %d\n", sdci[17]);
5940 if ( sdci[17] <= 0 )
5941 {
5942 Z_scripterrlog("bitmap->Read() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5943 return;
5944 }
5945 int32_t bitid = sdci[17] - 10;
5946 scb.script_created_bitmaps[bitid].destroy();
5947
5948 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5949
5950 //char *cptr = new char[str->size()+1]; // +1 to account for \0 byte
5951 // std::strncpy(cptr, str->c_str(), str->size());
5952 // Z_scripterrlog("The following should be the filename string:\n");
5953 //Z_scripterrlog(" %s\n", cptr);
5954
5955 if(!str)
5956 {
5957 al_trace("String pointer is null! Internal error. \n");
5958 return;
5959 }
5960
5961 // Z_scripterrlog("Trying to read filename %s\n", cptr);
5962 PALETTE tempPal;
5963 get_palette(tempPal);
5964 if ( checkPath(str->c_str(), false) )
5965 {
5966 scb.script_created_bitmaps[bitid].u_bmp = load_bitmap(str->c_str(), tempPal);
5967 scb.script_created_bitmaps[bitid].width = scb.script_created_bitmaps[bitid].u_bmp->w;
5968 scb.script_created_bitmaps[bitid].height = scb.script_created_bitmaps[bitid].u_bmp->h;
5969 if ( !scb.script_created_bitmaps[bitid].u_bmp )
5970 {
5971 Z_scripterrlog("Failed to load image file %s.\nMaking a blank bitmap on the pointer.\n", str->c_str());
5972 //scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,256,176);
5973 //clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5974 }
5975 else
5976 {
5977 zprint("Read image file %s\n",str->c_str());
5978 }
5979 }
5980 else
5981 {
5982 Z_scripterrlog("Failed to load image file: %s. File not found. Creating a blank bitmap on the pointer.\n", str->c_str());
5983 scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,256,176);
5984 clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5985 }
5986 }
5987
5988
5989
5990 void bmp_do_writer(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5991 {
5992 //sdci[1]=layer
5993 //sdci[2]=filename
5994 //sdci[3]=y
5995 //sdci[4]=font
5996 //sdci[5]=color
5997 //sdci[6]=bg color
5998 //sdci[7]=format_option
5999 //sdci[8]=string
6000 //sdci[9]=opacity
6001 //sdci[17] Bitmap Pointer
6002 //Z_scripterrlog("bitmap->Write() pointer is: %d\n", sdci[17]);
6003
6004 if ( sdci[17] <= 0 )
6005 {
6006 Z_scripterrlog("bitmap->Write() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6007 return;
6008 }
6009 int32_t bitid = sdci[17] - 10;
6010
6011 if ( !scb.script_created_bitmaps[bitid].u_bmp )
6012 {
6013 Z_scripterrlog("Tried to write from an invalid bitmap pointer %d. Aborting. \n", sdci[17]);
6014 return;
6015 }
6016
6017 bool overwrite = (sdci[3] != 0);
6018 std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
6019
6020 if(!str)
6021 {
6022 al_trace("String pointer is null! Internal error. \n");
6023 return;
6024 }
6025
6026 //char *cptr = new char[str->size()+1]; // +1 to account for \0 byte
6027 //std::strncpy(cptr, str->c_str(), str->size());
6028 //Z_scripterrlog("bitmap->Write extension matches ? : %s\n!", (FFCore.checkExtension(str->c_str(), ".png")) ? "true" : "false");
6029 //Z_scripterrlog("Trying to write filename %s\n", cptr);
6030 if
6031 (
6032 ( (FFCore.checkExtension(*str, "")) ) ||
6033 ( !(FFCore.checkExtension(*str, ".png")) && !(FFCore.checkExtension(*str, ".gif")) && !(FFCore.checkExtension(*str, ".bmp"))
6034 && !(FFCore.checkExtension(*str, ".pcx")) && !(FFCore.checkExtension(*str, ".tga")) )
6035 )
6036 {
6037 Z_scripterrlog("No extension, or invalid extension provided for writing bitmap file %s. Could not write the file.\nValid types are .png, .gif, .pcx, .tgx, and .bmp. Aborting.\n",str->c_str());
6038 }
6039 else if ( overwrite || (!checkPath(str->c_str(), false)) )
6040 {
6041 if(create_path(str->c_str()))
6042 {
6043 save_bitmap(str->c_str(), scb.script_created_bitmaps[bitid].u_bmp, RAMpal);
6044 if(checkPath(str->c_str(), false))
6045 {
6046 zprint("Wrote image file %s\n",str->c_str());
6047 }
6048 else
6049 {
6050 Z_scripterrlog("Failed to create file '%s'\n",str->c_str());
6051 }
6052 }
6053 else
6054 {
6055 Z_scripterrlog("Cannot write file '%s' because the directory does not exist, and could not be created.\n", str->c_str());
6056 }
6057 }
6058 else Z_scripterrlog("Cannot write file '%s' because the file already exists in the specified path.\n", str->c_str());
6059 }
6060
6061
6062 void bmp_do_drawquadr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6063 {
6064 //sdci[1]=layer
6065 //sdci[2]=x1
6066 //sdci[3]=y1
6067 //sdci[4]=x2
6068 //sdci[5]=y2
6069 //sdci[6]=x3
6070 //sdci[7]=y3
6071 //sdci[8]=x4
6072 //sdci[9]=y4
6073 //sdci[10]=width
6074 //sdci[11]=height
6075 //sdci[12]=cset
6076 //sdci[13]=flip
6077 //sdci[14]=tile/combo
6078 //sdci[15]=polytype
6079 //sdci[16] = other bitmap as texture
6080 //sdci[17] Bitmap Pointer
6081 Z_scripterrlog("bitmap quad pointer: %d\n", sdci[17]);
6082 if ( sdci[17] <= 0 )
6083 {
6084 Z_scripterrlog("bitmap->Quad() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6085 return;
6086 }
6087 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6088
6089 if ( !refbmp ) return;
6090
6091 int32_t x1 = sdci[2]/10000;
6092 int32_t y1 = sdci[3]/10000;
6093 int32_t x2 = sdci[4]/10000;
6094 int32_t y2 = sdci[5]/10000;
6095 int32_t x3 = sdci[6]/10000;
6096 int32_t y3 = sdci[7]/10000;
6097 int32_t x4 = sdci[8]/10000;
6098 int32_t y4 = sdci[9]/10000;
6099 int32_t w = sdci[10]/10000;
6100 int32_t h = sdci[11]/10000;
6101 int32_t color = sdci[12]/10000;
6102 int32_t flip=(sdci[13]/10000)&3;
6103 int32_t tile = sdci[14]/10000;
6104 int32_t polytype = sdci[15]/10000;
6105 int32_t quad_render_source = sdci[16]-10;
6106 //Z_scripterrlog("bitmap->Quad() render source is: %d\n", quad_render_source);
6107
6108 bool tex_is_bitmap = ( sdci[16] != 0 );
6109
6110 BITMAP *bmptexture=NULL;
6111 BITMAP *tex=NULL;
6112 polytype = vbound(polytype, 0, 14);
6113
6114 int32_t col[4];
6115 col[0]=col[1]=col[2]=col[3]=color;
6116 bool mustDestroyBmp = false;
6117
6118 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6119
6120 if ( tex_is_bitmap )
6121 {
6122 bmptexture = FFCore.GetScriptBitmap(quad_render_source);
6123 if ( !bmptexture )
6124 {
6125 Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
6126 tex_is_bitmap = 0;
6127 }
6128 }
6129
6130 if ( tex_is_bitmap )
6131 {
6132
6133 if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
6134 if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
6135 if ( !isPowerOfTwo(w) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", w);
6136 if ( !isPowerOfTwo(h) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", h);
6137
6138 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6139 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(h), col[1] };
6140 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(w), static_cast<float>(h), col[2] };
6141 V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(w), 0, col[3] };
6142
6143 quad3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3, &V4);
6144 }
6145 else
6146 {
6147 tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
6148 if(!tex)
6149 {
6150 //Z_scripterrlog("Bitmap->Quad() found an invalid texture bitmap.\n");
6151 mustDestroyBmp = true;
6152 tex = create_bitmap_ex(8, w*16, h*16);
6153 clear_bitmap(tex);
6154 }
6155
6156 if(tile > 0) // TILE
6157 {
6158 TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
6159 }
6160
6161 if ( tile < 0 ) // COMBO
6162 {
6163 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
6164 const int32_t tiletodraw = combo_tile(c, x1, y1);
6165 flip = flip ^ c.flip;
6166
6167 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
6168 }
6169 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
6170 {
6171 Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
6172 return; //non power of two error
6173 }
6174 //Z_scripterrlog("bitmap->Quad() is trying to blit from a bitmap texture.\n");
6175 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6176 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(h), col[1] };
6177 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(w), static_cast<float>(h), col[2] };
6178 V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(w), 0, col[3] };
6179
6180 quad3d_f(refbmp, polytype, tex, &V1, &V2, &V3, &V4);
6181
6182 }
6183
6184
6185
6186
6187 //todo: finish palette shading
6188 /*
6189 POLYTYPE_FLAT
6190 POLYTYPE_GCOL
6191 POLYTYPE_GRGB
6192 POLYTYPE_ATEX
6193 POLYTYPE_PTEX
6194 POLYTYPE_ATEX_MASK
6195 POLYTYPE_PTEX_MASK
6196 POLYTYPE_ATEX_LIT
6197 POLYTYPE_PTEX_LIT
6198 POLYTYPE_ATEX_MASK_LIT
6199 POLYTYPE_PTEX_MASK_LIT
6200 POLYTYPE_ATEX_TRANS
6201 POLYTYPE_PTEX_TRANS
6202 POLYTYPE_ATEX_MASK_TRANS
6203 POLYTYPE_PTEX_MASK_TRANS
6204 */
6205
6206 if(mustDestroyBmp)
6207 destroy_bitmap(tex);
6208
6209 }
6210
6211
6212 void bmp_do_getpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6213 {
6214 //sdci[1]=layer
6215 //sdci[2]=x1
6216 //sdci[3]=y1
6217
6218 //sdci[17] Bitmap Pointer
6219 if ( sdci[17] <= 0 )
6220 {
6221 Z_scripterrlog("bitmap->GetPixel() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6222 return;
6223 }
6224 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6225 if ( refbmp == NULL ) return;
6226
6227
6228 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6229
6230 int32_t x1 = sdci[2]/10000;
6231 int32_t y1 = (sdci[3]/10000)+yoffset;
6232 int32_t col = getpixel(scb.script_created_bitmaps[(sdci[17]-10)].u_bmp, x1, y1);
6233 Z_scripterrlog("bitmap->GetPixel col is %d\n",col);
6234 Z_scripterrlog("bitmap->GetPixel bitmap ptr is is %d\n",(sdci[17]-10));
6235 FFCore.set_sarg1(col);
6236 }
6237
6238
6239
6240
6241 void bmp_do_drawtriangler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6242 {
6243 //sdci[1]=layer
6244 //sdci[2]=x1
6245 //sdci[3]=y1
6246 //sdci[4]=x2
6247 //sdci[5]=y2
6248 //sdci[6]=x3
6249 //sdci[7]=y3
6250 //sdci[8]=width
6251 //sdci[9]=height
6252 //sdci[10]=cset
6253 //sdci[11]=flip
6254 //sdci[12]=tile/combo
6255 //sdci[13]=polytype
6256 //sdci[17] Bitmap Pointer
6257 if ( sdci[17] <= 0 )
6258 {
6259 Z_scripterrlog("bitmap->Triangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6260 return;
6261 }
6262 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6263 if ( refbmp == NULL ) return;
6264
6265
6266 int32_t render_source = sdci[14]-10;
6267 //Z_scripterrlog("bitmap->Triangle() render source is: %d\n", render_source);
6268
6269 bool tex_is_bitmap = ( sdci[14] != 0 );
6270
6271 BITMAP *bmptexture=NULL;
6272 if ( tex_is_bitmap )
6273 {
6274 bmptexture = FFCore.GetScriptBitmap(render_source);
6275 if ( !bmptexture )
6276 {
6277 Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
6278 tex_is_bitmap = 0;
6279 }
6280 }
6281
6282 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6283
6284 int32_t x1 = sdci[2]/10000;
6285 int32_t y1 = sdci[3]/10000;
6286 int32_t x2 = sdci[4]/10000;
6287 int32_t y2 = sdci[5]/10000;
6288 int32_t x3 = sdci[6]/10000;
6289 int32_t y3 = sdci[7]/10000;
6290 int32_t w = sdci[8]/10000;
6291 int32_t h = sdci[9]/10000;
6292 int32_t color = sdci[10]/10000;
6293 int32_t flip=(sdci[11]/10000)&3;
6294 int32_t tile = sdci[12]/10000;
6295 int32_t polytype = sdci[13]/10000;
6296
6297 polytype = vbound(polytype, 0, 14);
6298 int32_t utex_w = w;
6299 int32_t utex_h = h;
6300
6301
6302 int32_t tex_width = w*16;
6303 int32_t tex_height = h*16;
6304
6305 bool mustDestroyBmp = false;
6306 BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
6307
6308 if(!tex)
6309 {
6310 mustDestroyBmp = true;
6311 tex = create_bitmap_ex(8, tex_width, tex_height);
6312 clear_bitmap(tex);
6313 }
6314
6315 int32_t col[3];
6316 /*
6317 if( color < 0 )
6318 {
6319 col[0]=draw_container.color_buffer[0];
6320 col[1]=draw_container.color_buffer[1];
6321 col[2]=draw_container.color_buffer[2];
6322 }
6323 else */
6324 {
6325 col[0]=col[1]=col[2]=color;
6326 }
6327
6328 if(tile > 0) // TILE
6329 {
6330 TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
6331 }
6332 else // COMBO
6333 {
6334 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
6335 const int32_t tiletodraw = combo_tile(c, x1, y1);
6336 flip = flip ^ c.flip;
6337
6338 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
6339 }
6340 if ( !tex_is_bitmap )
6341 {
6342 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
6343 {
6344 Z_message("bitmap->Triangle() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
6345 return; //non power of two error
6346 }
6347 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6348 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
6349 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
6350
6351
6352 triangle3d_f(refbmp, polytype, tex, &V1, &V2, &V3);
6353
6354 }
6355
6356 else
6357 {
6358 if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", render_source);
6359 if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", render_source);
6360 if ( !isPowerOfTwo(utex_h) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", utex_w);
6361 if ( !isPowerOfTwo(utex_w) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", utex_h);
6362
6363 V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6364 V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(utex_h), col[1] };
6365 V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(utex_w), static_cast<float>(utex_h), col[2] };
6366
6367
6368 triangle3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3);
6369
6370 }
6371
6372 if(mustDestroyBmp)
6373 destroy_bitmap(tex);
6374 }
6375
6376
6377 void bmp_do_mode7r(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6378 {
6379 /*
6380 int32_t layer, int32_t rt, int32_t srcX, int32_t srcY, int32_t srcW, int32_t srcH, int32_t destW, int32_t destH, int32_t angle, int32_t cx, int32_t cy, int32_t space_z, int32_t horizon,
6381 int32_t scale_x, int32_t scale_y){
6382
6383 //sdci[1]=layer
6384 //sdci[2]=bitmap target
6385 //
6386 // -2 is the current Render Target
6387 // -1, this is the screen (framebuf).
6388 // 0: Render target 0
6389 // 1: Render target 1
6390 // 2: Render target 2
6391 // 3: Render target 3
6392 // 4: Render target 4
6393 // 5: Render target 5
6394 // 6: Render target 6
6395 // Otherwise: The pointer to a bitmap.
6396
6397 //sdci[3]=sourcex
6398 //sdci[4]=sourcey
6399 //sdci[5]=sourcew
6400 //sdci[6]=sourceh
6401
6402 //sdci[7]=destw
6403 //sdci[8]=desth
6404 //sdci[9]=angle
6405 //scdi[10] = pivot cx
6406 //sdci[11] = pivot cy
6407 //sdci[12] = space Z
6408 //sdci[13] = horizon
6409 //scdi[14] = scale X
6410 //scdi[15] = scale Y
6411 //sdci[16] = masked?
6412 //sdci[17] Bitmap Pointer
6413
6414
6415
6416 // ZScript-side constant values:
6417 const int32_t BITDX_NORMAL = 0;
6418 const int32_t BITDX_TRANS = 1; //Translucent
6419 const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
6420 const int32_t BITDX_HFLIP = 4; //Horizontal Flip
6421 const int32_t BITDX_VFLIP = 8; //Vertical Flip.
6422 //Note: Some modes cannot be combined. if a combination is not supported, an error
6423 // detailing this will be shown in allegro.log.
6424
6425 //scdi[15] = litcolour
6426 //The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
6427 //not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
6428
6429 //sdci[16]=mask
6430
6431 */
6432
6433
6434 int32_t bitmapIndex = sdci[2];
6435 int32_t usr_bitmap_index = sdci[2]-10;
6436 byte using_user_bitmap = 0;
6437 //Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
6438 //Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
6439 #if LOG_BMPBLIT_LEVEL > 0
6440 Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
6441 #endif
6442 if ( bitmapIndex >= 10000 )
6443 {
6444 bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
6445 }
6446 else if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
6447 {
6448 bitmapIndex = usr_bitmap_index;
6449 using_user_bitmap = 1;
6450 Z_scripterrlog("Mode7 is using a user bitmap target, pointer: %d\n", usr_bitmap_index);
6451 yoffset = 0;
6452 }
6453
6454 //int32_t sx = sdci[3]/10000;
6455 //int32_t sy = sdci[4]/10000;
6456 //int32_t sw = sdci[5]/10000;
6457 //Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
6458 //int32_t sh = sdci[6]/10000;
6459 //Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
6460 //int32_t dx = sdci[7]/10000;
6461 //int32_t dy = sdci[8]/10000;
6462 //int32_t dw = sdci[9]/10000;
6463 //int32_t dh = sdci[10]/10000;
6464 //float rot = sdci[11]/10000;
6465 //int32_t cx = sdci[12]/10000;
6466 //int32_t cy = sdci[13]/10000;
6467 //int32_t mode = sdci[14]/10000;
6468 //int32_t litcolour = sdci[15]/10000;
6469
6470 //rendering mode 7 args
6471 double srcX = sdci[3]/10000.0;
6472 double srcY = sdci[4]/10000.0;
6473 double destX = sdci[5]/10000.0;
6474 double destY = sdci[6]/10000.0;
6475
6476
6477 // int32_t srcW = sdci[5]/10000;
6478 // int32_t srcH = sdci[6]/10000;
6479 double destW = sdci[7]/10000.0;
6480 double destH = sdci[8]/10000.0;
6481 // int32_t angle = sdci[9]/10000;
6482 // int32_t cx = sdci[10]/10000;
6483 // int32_t cy = sdci[11]/10000;
6484 double space_z = sdci[9]/10000.0;
6485 double horizon = sdci[10]/10000.0;
6486 double scale_x = sdci[11]/10000.0;
6487 double scale_y = sdci[12]/10000.0;
6488 byte masked = ( sdci[13] ) ? 1 : 0;
6489
6490
6491 int32_t ref = 0;
6492
6493 //dx = 0 + xoffset;
6494 //dy = 0 + yoffset;
6495
6496 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6497 //Do we need to also check the render target and do the same thing if the
6498 //dest == -2 and the render target is not RT_SCREEN?
6499
6500 ref = sdci[17];
6501 //Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
6502 ref -=10;
6503 //Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
6504
6505
6506 if ( ref <= 0 )
6507 {
6508 Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
6509 return;
6510 }
6511 BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
6512 #if LOG_BMPBLIT_LEVEL > 0
6513 Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
6514 #endif
6515 if(!sourceBitmap)
6516 {
6517 Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
6518 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6519 return;
6520 }
6521
6522 BITMAP *destBMP=NULL;
6523 //zprint2("mode 7 bitmap index is: %d\n",bitmapIndex);
6524 switch(bitmapIndex)
6525 {
6526 case -2:
6527 {
6528 int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
6529 //zprint2("current RT is: %d\n", curr_rt);
6530 if ( curr_rt >= 0 && curr_rt < 7 )
6531 destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
6532 else destBMP = bmp; //screen
6533 break;
6534 }
6535 case -1:
6536 destBMP = bmp; //this is framebuf, by default
6537 break;
6538 //zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
6539 //destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6540 //destBMP = framebuf; //Drawing to the screen.
6541 //break;
6542
6543 //1 through 6 are the old system bitmaps (Render Targets)
6544 case 0:
6545 case 1:
6546 case 2:
6547 case 3:
6548 case 4:
6549 case 5:
6550 case 6:
6551 {
6552 //This gets a render target.
6553 //destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
6554
6555 destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
6556 //sdci[18] = bitmapIndex;
6557 break;
6558 }
6559 //Otherwise, we are using a user-created bitmap, so, get that pointer insted.
6560 default:
6561 {
6562 destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
6563 //sdci[18] = usr_bitmap_index;
6564 if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
6565 {
6566 Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
6567 break;
6568 }
6569 }
6570 //FFCore.get_user_bitmap(bitmapIndex); break;
6571 }
6572
6573
6574
6575 #if LOG_BMPBLIT_LEVEL > 0
6576 Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
6577 #endif
6578
6579
6580 if (!destBMP)
6581 {
6582 Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
6583 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6584 return;
6585 }
6586
6587 //bugfix
6588 //sx = vbound(sx, 0, sourceBitmap->w);
6589 /* //These vars are named wrongly for this function -V
6590 #if LOG_BMPBLIT_LEVEL > 0
6591 Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
6592 Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
6593 #endif
6594 //sy = vbound(sy, 0, sourceBitmap->h);
6595 #if LOG_BMPBLIT_LEVEL > 0
6596 Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
6597 Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
6598 #endif
6599 //sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
6600 #if LOG_BMPBLIT_LEVEL > 0
6601 Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
6602 #endif
6603 //sh = vbound(sh, 0, sourceBitmap->h - sy);
6604 #if LOG_BMPBLIT_LEVEL > 0
6605 Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
6606
6607 Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
6608 Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
6609 #endif
6610 //bool stretched = (sw != dw || sh != dh);
6611 //bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
6612 #if LOG_BMPBLIT_LEVEL > 0
6613 Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
6614 #endif
6615 */
6616 //BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6617
6618
6619
6620
6621
6622 BITMAP* subBmp = 0;
6623
6624 /* IDR what this was. -Z ( 17th April, 2019 )
6625 if ( bitmapIndex == -1 ) {
6626 blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
6627 }
6628 */
6629
6630 //if(rot != 0 || mode != 0)
6631 //{
6632 // subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
6633 // clear_bitmap(subBmp);
6634
6635 // if(!subBmp)
6636 // {
6637 // Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
6638 // return;
6639 // }
6640 //}
6641
6642
6643 //dx = dx + xoffset; //don't do this here!
6644 //dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
6645 //All of these are a factor of 10000 as fix.
6646 int32_t screen_x = 0; int32_t screen_y = 0;
6647
6648 double distance = 0; double horizontal_scale = 0;
6649
6650 int32_t screen_y_horizon = 0;
6651
6652 double line_dx = 0; double line_dy = 0;
6653
6654 int32_t space_x = 0; int32_t space_y = 0;
6655
6656 for(screen_y = 0; screen_y < destH; screen_y++) //fix, offset by .0000
6657 {
6658 //Calculate the distance of each line from the camera point
6659 screen_y_horizon = screen_y + horizon;
6660
6661 distance = ((space_z * scale_y) / ((screen_y_horizon != 0) ? screen_y_horizon : 1));
6662
6663 //Get the scale of each line based on the distance
6664
6665 horizontal_scale = (distance / (( scale_x != 0 ) ? scale_x : 1));
6666
6667 //There was some math here before I stripped out the rotation step
6668 line_dx = horizontal_scale;
6669 line_dy = 0;
6670
6671 //space_x,space_y - where to grab each scanline from on the space bitmap
6672 space_x = srcX - destW/2.0 * line_dx;
6673 space_y = srcY - distance + destH/2.0 * line_dy;
6674
6675 //Keep blits within the bounds of both bitmaps to avoid crashes
6676 int32_t y1 = srcY+space_y;
6677 int32_t y2 = destY+screen_y;
6678 if(y1 >=0 && y1 <= (sourceBitmap->h-1) && y2 >=0 && y2 <= (destBMP->h-1) )
6679 {
6680 if ( masked ) masked_stretch_blit(sourceBitmap, destBMP, (int32_t)(srcX+space_x), (int32_t)(srcY+space_y),
6681 (int32_t)(line_dx*destW), 1, (int32_t)(screen_x), (int32_t)(screen_y)+yoffset, (int32_t)(destW), 1);
6682 else stretch_blit(sourceBitmap, destBMP, (int32_t)(srcX+space_x), (int32_t)(srcY+space_y),
6683 (int32_t)(line_dx*destW), 1, (int32_t)(screen_x), (int32_t)(screen_y)+yoffset, (int32_t)(destW), 1);
6684 }
6685 }
6686
6687
6688 //cleanup
6689 if(subBmp)
6690 {
6691 //script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
6692 destroy_bitmap(subBmp);
6693 }
6694 }
6695
6696
6697 //Draw]()
6698 void bmp_do_drawbitmapexr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6699 {
6700 /*
6701 //sdci[1]=layer
6702 //sdci[2]=bitmap target
6703 //
6704 // -2 is the current Render Target
6705 // -1, this is the screen (framebuf).
6706 // 0: Render target 0
6707 // 1: Render target 1
6708 // 2: Render target 2
6709 // 3: Render target 3
6710 // 4: Render target 4
6711 // 5: Render target 5
6712 // 6: Render target 6
6713 // Otherwise: The pointer to a bitmap.
6714
6715 //sdci[3]=sourcex
6716 //sdci[4]=sourcey
6717 //sdci[5]=sourcew
6718 //sdci[6]=sourceh
6719 //sdci[7]=destx
6720 //sdci[8]=desty
6721 //sdci[9]=destw
6722 //sdci[10]=desth
6723 //sdci[11]=rotation/angle
6724 //scdi[12] = pivot cx
6725 //sdci[13] = pivot cy
6726 //scdi[14] = effect flags
6727 //sdci[17] Bitmap Pointer
6728
6729 // ZScript-side constant values:
6730 const int32_t BITDX_NORMAL = 0;
6731 const int32_t BITDX_TRANS = 1; //Translucent
6732 const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
6733 const int32_t BITDX_HFLIP = 4; //Horizontal Flip
6734 const int32_t BITDX_VFLIP = 8; //Vertical Flip.
6735 //Note: Some modes cannot be combined. if a combination is not supported, an error
6736 // detailing this will be shown in allegro.log.
6737
6738 //scdi[15] = litcolour
6739 //The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
6740 //not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
6741
6742 //sdci[16]=mask
6743
6744 */
6745
6746 int32_t bitmapIndex = sdci[2]/10000;
6747 int32_t usr_bitmap_index = sdci[2]-10;
6748 byte using_user_bitmap = 0;
6749 //Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
6750 //Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
6751 #if LOG_BMPBLIT_LEVEL > 0
6752 Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
6753 #endif
6754 if ( bitmapIndex > 10000 )
6755 {
6756 bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
6757 }
6758 if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
6759 {
6760 bitmapIndex = usr_bitmap_index;
6761 using_user_bitmap = 1;
6762 yoffset = 0;
6763 }
6764
6765 int32_t sx = sdci[3]/10000;
6766 int32_t sy = sdci[4]/10000;
6767 int32_t sw = sdci[5]/10000;
6768 //Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
6769 int32_t sh = sdci[6]/10000;
6770 //Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
6771 int32_t dx = sdci[7]/10000;
6772 int32_t dy = sdci[8]/10000;
6773 int32_t dw = sdci[9]/10000;
6774 int32_t dh = sdci[10]/10000;
6775 float rot = sdci[11]/10000;
6776 int32_t cx = sdci[12]/10000;
6777 int32_t cy = sdci[13]/10000;
6778 int32_t mode = sdci[14]/10000;
6779 int32_t litcolour = sdci[15]/10000;
6780 bool masked = (sdci[16] != 0);
6781
6782 int32_t ref = 0;
6783
6784 dx = dx + xoffset;
6785 dy = dy + yoffset;
6786
6787 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6788 //Do we need to also check the render target and do the same thing if the
6789 //dest == -2 and the render target is not RT_SCREEN?
6790
6791 ref = sdci[17];
6792 //Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
6793 ref -=10;
6794 //Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
6795
6796
6797 if ( ref <= 0 )
6798 {
6799 Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
6800 return;
6801 }
6802 BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
6803 #if LOG_BMPBLIT_LEVEL > 0
6804 Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
6805 #endif
6806 if(!sourceBitmap)
6807 {
6808
6809 Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
6810 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6811 return;
6812 }
6813
6814 BITMAP *destBMP=NULL;
6815 //zprint2("blit () bitmap index is: %d\n",bitmapIndex);
6816 switch(bitmapIndex)
6817 {
6818 case -2:
6819 {
6820 int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
6821 //zprint2("current RT is: %d\n", curr_rt);
6822 if ( curr_rt >= 0 && curr_rt < 7 )
6823 destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
6824 else destBMP = bmp; //screen
6825 break;
6826 }
6827 case -1:
6828 destBMP = bmp; //this is framebuf, by default
6829 break;
6830 //zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
6831 //destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6832 //destBMP = framebuf; //Drawing to the screen.
6833 //break;
6834
6835 //1 through 6 are the old system bitmaps (Render Targets)
6836 case 0:
6837 case 1:
6838 case 2:
6839 case 3:
6840 case 4:
6841 case 5:
6842 case 6:
6843 {
6844 //This gets a render target.
6845 destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
6846
6847 //destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
6848 //sdci[18] = bitmapIndex;
6849 break;
6850 }
6851 //Otherwise, we are using a user-created bitmap, so, get that pointer insted.
6852 default:
6853 {
6854 destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
6855 //sdci[18] = usr_bitmap_index;
6856 if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
6857 {
6858 Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
6859 break;
6860 }
6861 }
6862 //FFCore.get_user_bitmap(bitmapIndex); break;
6863 }
6864
6865
6866
6867 #if LOG_BMPBLIT_LEVEL > 0
6868 Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
6869 #endif
6870
6871
6872 if (!destBMP)
6873 {
6874
6875 Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
6876 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6877 return;
6878 }
6879
6880 //bugfix
6881 //sx = vbound(sx, 0, sourceBitmap->w);
6882 #if LOG_BMPBLIT_LEVEL > 0
6883 Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
6884 Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
6885 #endif
6886 //sy = vbound(sy, 0, sourceBitmap->h);
6887 #if LOG_BMPBLIT_LEVEL > 0
6888 Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
6889 Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
6890 #endif
6891 //sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
6892 #if LOG_BMPBLIT_LEVEL > 0
6893 Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
6894 #endif
6895 //sh = vbound(sh, 0, sourceBitmap->h - sy);
6896 #if LOG_BMPBLIT_LEVEL > 0
6897 Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
6898
6899 Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
6900 Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
6901 #endif
6902 bool stretched = (sw != dw || sh != dh);
6903 //bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
6904 #if LOG_BMPBLIT_LEVEL > 0
6905 Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
6906 #endif
6907 //BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6908
6909
6910
6911
6912
6913 BITMAP* subBmp = 0;
6914
6915 /* IDR what this was. -Z ( 17th April, 2019 )
6916 if ( bitmapIndex == -1 ) {
6917 blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
6918 }
6919 */
6920
6921 if(rot != 0 || mode != 0)
6922 {
6923 subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
6924 clear_bitmap(subBmp);
6925
6926 if(!subBmp)
6927 {
6928
6929 Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
6930 return;
6931 }
6932 }
6933 BITMAP* sbmp = sourceBitmap;
6934 if (sx + sw > sbmp->w || sy + sh > sbmp->h)
6935 {
6936 sbmp = create_bitmap_ex(8, sw, sh);
6937 clear_bitmap(sbmp);
6938 blit(sourceBitmap, sbmp, sx, sy, 0, 0, std::min(sourceBitmap->w-sx, sw), std::min(sourceBitmap->h-sy, sh));
6939 sx = 0;
6940 sy = 0;
6941 }
6942 //dx = dx + xoffset; //don't do this here!
6943 //dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
6944
6945 if(stretched)
6946 {
6947 if(masked)
6948 { //stretched and masked
6949 if ( rot == 0 )
6950 { //if not rotated
6951 switch(mode)
6952 {
6953 case 1:
6954 //transparent
6955 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6956 draw_trans_sprite(destBMP, subBmp, dx, dy);
6957 break;
6958
6959
6960 case 2:
6961 //pivot?
6962 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6963 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6964 //Pivoting requires two more args
6965 break;
6966
6967 case 3:
6968 //pivot + trans
6969 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6970 pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6971 break;
6972
6973 case 4:
6974 //flip v
6975 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6976 draw_sprite_v_flip(destBMP, subBmp, dx, dy);
6977 break;
6978
6979 case 5:
6980 //trans + v flip
6981 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6982 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
6983 break;
6984
6985 case 6:
6986 //pivot + v flip
6987 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6988 pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6989 break;
6990
6991 case 8:
6992 //vlip h
6993 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6994 draw_sprite_h_flip(destBMP, subBmp, dx, dy);
6995 break;
6996
6997 case 9:
6998 //trans + h flip
6999 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7000 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7001 break;
7002
7003 case 10:
7004 //flip H and pivot
7005 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7006 //return error cannot pivot and h flip
7007 break;
7008
7009 case 12:
7010 //vh flip
7011 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7012 draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7013 break;
7014
7015 case 13:
7016 //trans + vh flip
7017 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7018 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7019 break;
7020
7021 case 14:
7022 //pivot and vh flip
7023 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7024 //return error cannot both pivot and vh flip
7025 break;
7026
7027 case 16:
7028 //lit
7029 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7030 draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7031 break;
7032
7033 case 18:
7034 //pivot, lit
7035 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7036 pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7037 break;
7038
7039 case 20:
7040 //lit + v flip
7041 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7042 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7043 break;
7044
7045 case 22:
7046 //Pivot, vflip, lit
7047 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7048 pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7049 break;
7050
7051 case 24:
7052 //lit + h flip
7053 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7054 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7055 break;
7056
7057 case 26:
7058 //pivot + lit + hflip
7059 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7060 //return error cannot pivot, lit, and flip
7061 break;
7062
7063 case 28:
7064 //lit + vh flip
7065 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7066 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7067 break;
7068
7069 case 32: //gouraud
7070 //Probably not wort supporting.
7071 //masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7072 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7073 break;
7074
7075 case 0:
7076 //no effect
7077 masked_stretch_blit(sbmp, destBMP, sx, sy, sw, sh, dx, dy, dw, dh);
7078 break;
7079
7080
7081 default:
7082
7083 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7084
7085
7086 }
7087 } //end if not rotated
7088
7089 if ( rot != 0 ) //if rotated
7090 {
7091 switch(mode)
7092 {
7093 case 1:
7094 //transparent
7095 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7096 rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7097
7098 break;
7099
7100 case 2:
7101 //pivot?
7102 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7103 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7104 //Pivoting requires two more args
7105 break;
7106
7107 case 3:
7108 //pivot + trans
7109 //return an error, cannot both rotate and pivot
7110 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7111 break;
7112
7113 case 4:
7114 //flip v
7115 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7116 rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7117 break;
7118
7119 case 5:
7120 //trans + v flip
7121 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7122 rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7123 break;
7124
7125 case 6:
7126 //pivot + v flip
7127 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7128 //return an error, cannot both rotate and pivot
7129 break;
7130
7131 case 8:
7132 //flip h
7133 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7134 //return an error, cannot both rotate and flip H
7135 break;
7136
7137 case 9:
7138 //trans + h flip
7139 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7140 //return an error, cannot rotate and flip a trans sprite
7141 break;
7142
7143 case 10:
7144 //flip H and pivot
7145 //return error cannot pivot and h flip
7146 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7147 break;
7148
7149 case 12:
7150 //vh flip
7151 //return an error, cannot rotate and VH flip a trans sprite
7152 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7153 break;
7154
7155 case 13:
7156 //trans + vh flip
7157 //return an error, cannot rotate and VH flip a trans sprite
7158 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7159 break;
7160
7161 case 14:
7162 //pivot and vh flip
7163 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7164 //return error cannot both pivot and vh flip
7165 break;
7166
7167 case 16:
7168 //lit
7169 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7170 rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7171 break;
7172
7173 case 18:
7174 //pivot, lit
7175 //return an error, cannot both rotate and pivot
7176 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7177 break;
7178
7179 case 20:
7180 //lit + vflip
7181 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7182 rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7183 break;
7184
7185 case 22:
7186 //Pivot, vflip, lit
7187 //return an error, cannot both rotate and pivot
7188 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7189 break;
7190
7191 case 24:
7192 //lit + h flip
7193 //return an error, cannot both rotate and H flip
7194 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7195 break;
7196
7197 case 26:
7198 //pivot + lit + hflip
7199 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7200 //return error cannot pivot, lit, and flip
7201 break;
7202
7203 case 28:
7204 //lit + vh flip
7205 //return an error, cannot both rotate and VH flip
7206 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7207 break;
7208
7209 case 32: //gouraud
7210 //Probably not wort supporting.
7211 //masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7212 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7213 break;
7214
7215 case 0:
7216 //no effect.
7217 masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7218 rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7219 break;
7220
7221 default:
7222
7223 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7224
7225 }
7226 }
7227 } //end if stretched and masked
7228
7229 else //stretched, not masked
7230 {
7231
7232
7233 if ( rot == 0 ) //if not rotated
7234 {
7235 switch(mode)
7236 {
7237 case 1:
7238 //transparent
7239 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7240 draw_trans_sprite(destBMP, subBmp, dx, dy);
7241 break;
7242
7243
7244 case 2:
7245 //pivot?
7246 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7247 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7248 //Pivoting requires two more args
7249 break;
7250
7251 case 3:
7252 //pivot + trans
7253 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7254 pivot_sprite_trans(destBMP, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
7255 break;
7256
7257 case 4:
7258 //flip v
7259 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7260 draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7261 break;
7262
7263 case 5:
7264 //trans + v flip
7265 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7266 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7267 break;
7268
7269 case 6:
7270 //pivot + v flip
7271 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7272 pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7273 break;
7274
7275 case 8:
7276 //vlip h
7277 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7278 draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7279 break;
7280
7281 case 9:
7282 //trans + h flip
7283 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7284 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7285 break;
7286
7287 case 10:
7288 //flip H and pivot
7289 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7290 //return error cannot pivot and h flip
7291 break;
7292
7293 case 12:
7294 //vh flip
7295 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7296 draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7297 break;
7298
7299 case 13:
7300 //trans + vh flip
7301 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7302 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7303 break;
7304
7305 case 14:
7306 //pivot and vh flip
7307 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7308 //return error cannot both pivot and vh flip
7309 break;
7310
7311 case 16:
7312 //lit
7313 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7314 draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7315 break;
7316
7317 case 18:
7318 //pivot, lit
7319 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7320 pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7321 break;
7322
7323 case 20:
7324 //lit + v flip
7325 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7326 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7327 break;
7328
7329 case 22:
7330 //Pivot, vflip, lit
7331 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7332 pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7333 break;
7334
7335 case 24:
7336 //lit + h flip
7337 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7338 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7339 break;
7340
7341 case 26:
7342 //pivot + lit + hflip
7343 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7344 //return error cannot pivot, lit, and flip
7345 break;
7346
7347 case 28:
7348 //lit + vh flip
7349 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7350 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7351 break;
7352
7353 case 32: //gouraud
7354 //Probably not wort supporting.
7355 //stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7356 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7357 break;
7358
7359 case 0:
7360 //no effect
7361 stretch_blit(sbmp, destBMP, sx, sy, sw, sh, dx, dy, dw, dh);
7362 break;
7363
7364
7365 default:
7366
7367 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7368
7369
7370 }
7371 } //end if not rotated
7372
7373 if ( rot != 0 ) //if rotated
7374 {
7375 switch(mode)
7376 {
7377 case 1:
7378 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7379 rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7380
7381 break;
7382
7383 case 2:
7384 //pivot?
7385 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7386 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7387 //Pivoting requires two more args
7388 break;
7389
7390 case 3:
7391 //pivot + trans
7392 //return an error, cannot both rotate and pivot
7393 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7394 break;
7395
7396 case 4:
7397 //flip v
7398 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7399 rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7400 break;
7401
7402 case 5:
7403 //trans + v flip
7404 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7405 rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7406 break;
7407
7408 case 6:
7409 //pivot + v flip
7410 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7411 //return an error, cannot both rotate and pivot
7412 break;
7413
7414 case 8:
7415 //flip h
7416 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7417 //return an error, cannot both rotate and flip H
7418 break;
7419
7420 case 9:
7421 //trans + h flip
7422 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7423 //return an error, cannot rotate and flip a trans sprite
7424 break;
7425
7426 case 10:
7427 //flip H and pivot
7428 //return error cannot pivot and h flip
7429 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7430 break;
7431
7432 case 12:
7433 //vh flip
7434 //return an error, cannot rotate and VH flip a trans sprite
7435 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7436 break;
7437
7438 case 13:
7439 //trans + vh flip
7440 //return an error, cannot rotate and VH flip a trans sprite
7441 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7442 break;
7443
7444 case 14:
7445 //pivot and vh flip
7446 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7447 //return error cannot both pivot and vh flip
7448 break;
7449
7450 case 16:
7451 //lit
7452 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7453 rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7454 break;
7455
7456 case 18:
7457 //pivot, lit
7458 //return an error, cannot both rotate and pivot
7459 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7460 break;
7461
7462 case 20:
7463 //lit + vflip
7464 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7465 rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7466 break;
7467
7468 case 22:
7469 //Pivot, vflip, lit
7470 //return an error, cannot both rotate and pivot
7471 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7472 break;
7473
7474 case 24:
7475 //lit + h flip
7476 //return an error, cannot both rotate and H flip
7477 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7478 break;
7479
7480 case 26:
7481 //pivot + lit + hflip
7482 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7483 //return error cannot pivot, lit, and flip
7484 break;
7485
7486 case 28:
7487 //lit + vh flip
7488 //return an error, cannot both rotate and VH flip
7489 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7490 break;
7491
7492 case 32: //gouraud
7493 //Probably not wort supporting.
7494 //stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7495 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7496 break;
7497
7498 case 0:
7499 //no effect.
7500 stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7501 rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7502 break;
7503
7504 default:
7505
7506 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7507
7508 }
7509 }
7510
7511 } //end if stretched, but not masked
7512 }
7513 else //not stretched
7514 {
7515
7516 if(masked) //if masked, but not stretched
7517 {
7518
7519 if ( rot == 0 ) //if not rotated
7520 {
7521 switch(mode)
7522 {
7523 case 1:
7524 //transparent
7525 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7526 draw_trans_sprite(destBMP, subBmp, dx, dy);
7527 break;
7528
7529
7530 case 2:
7531 //pivot?
7532 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7533 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7534 //Pivoting requires two more args
7535 break;
7536
7537 case 3:
7538 //pivot + trans
7539 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7540 pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7541 break;
7542
7543 case 4:
7544 //flip v
7545 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7546 draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7547 break;
7548
7549 case 5:
7550 //trans + v flip
7551 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7552 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7553 break;
7554
7555 case 6:
7556 //pivot + v flip
7557 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7558 pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7559 break;
7560
7561 case 8:
7562 //vlip h
7563 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7564 draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7565 break;
7566
7567 case 9:
7568 //trans + h flip
7569 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7570 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7571 break;
7572
7573 case 10:
7574 //flip H and pivot
7575 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7576 //return error cannot pivot and h flip
7577 break;
7578
7579 case 12:
7580 //vh flip
7581 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7582 draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7583 break;
7584
7585 case 13:
7586 //trans + vh flip
7587 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7588 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7589 break;
7590
7591 case 14:
7592 //pivot and vh flip
7593 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7594 //return error cannot both pivot and vh flip
7595 break;
7596
7597 case 16:
7598 //lit
7599 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7600 draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7601 break;
7602
7603 case 18:
7604 //pivot, lit
7605 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7606 pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7607 break;
7608
7609 case 20:
7610 //lit + v flip
7611 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7612 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7613 break;
7614
7615 case 22:
7616 //Pivot, vflip, lit
7617 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7618 pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7619 break;
7620
7621 case 24:
7622 //lit + h flip
7623 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7624 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7625 break;
7626
7627 case 26:
7628 //pivot + lit + hflip
7629 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7630 //return error cannot pivot, lit, and flip
7631 break;
7632
7633 case 28:
7634 //lit + vh flip
7635 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7636 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7637 break;
7638
7639 case 32: //gouraud
7640 //Probably not wort supporting.
7641 //stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7642 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7643 break;
7644
7645 case 0:
7646 //no effect
7647 masked_blit(sbmp, destBMP, sx, sy, dx, dy, dw, dh);
7648 break;
7649
7650
7651 default:
7652
7653 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7654
7655
7656 }
7657 } //end if not rotated
7658
7659 if ( rot != 0 ) //if rotated
7660 {
7661 switch(mode)
7662 {
7663 case 1:
7664 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh); //transparent
7665 rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7666
7667 break;
7668
7669 case 2:
7670 //pivot?
7671 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7672 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7673 //Pivoting requires two more args
7674 break;
7675
7676 case 3:
7677 //pivot + trans
7678 //return an error, cannot both rotate and pivot
7679 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7680 break;
7681
7682 case 4:
7683 //flip v
7684 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7685 rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7686 break;
7687
7688 case 5:
7689 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
7690 rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7691 break;
7692
7693 case 6:
7694 //pivot + v flip
7695 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7696 //return an error, cannot both rotate and pivot
7697 break;
7698
7699 case 8:
7700 //flip h
7701 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7702 //return an error, cannot both rotate and flip H
7703 break;
7704
7705 case 9:
7706 //trans + h flip
7707 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7708 //return an error, cannot rotate and flip a trans sprite
7709 break;
7710
7711 case 10:
7712 //flip H and pivot
7713 //return error cannot pivot and h flip
7714 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7715 break;
7716
7717 case 12:
7718 //vh flip
7719 //return an error, cannot rotate and VH flip a trans sprite
7720 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7721 break;
7722
7723 case 13:
7724 //trans + vh flip
7725 //return an error, cannot rotate and VH flip a trans sprite
7726 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7727 break;
7728
7729 case 14:
7730 //pivot and vh flip
7731 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7732 //return error cannot both pivot and vh flip
7733 break;
7734
7735 case 16:
7736 //lit
7737 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7738 rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7739 break;
7740
7741 case 18:
7742 //pivot, lit
7743 //return an error, cannot both rotate and pivot
7744 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7745 break;
7746
7747 case 20:
7748 //lit + vflip
7749 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7750 rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7751 break;
7752
7753 case 22:
7754 //Pivot, vflip, lit
7755 //return an error, cannot both rotate and pivot
7756 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7757 break;
7758
7759 case 24:
7760 //lit + h flip
7761 //return an error, cannot both rotate and H flip
7762 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7763 break;
7764
7765 case 26:
7766 //pivot + lit + hflip
7767 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7768 //return error cannot pivot, lit, and flip
7769 break;
7770
7771 case 28:
7772 //lit + vh flip
7773 //return an error, cannot both rotate and VH flip
7774 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7775 break;
7776
7777 case 32: //gouraud
7778 //Probably not wort supporting.
7779 //stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7780 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7781 break;
7782
7783 case 0:
7784 //no effect.
7785 masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7786 rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7787 break;
7788
7789 default:
7790
7791 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7792
7793 }
7794 } //end rtated, masked
7795 } //end if masked
7796
7797 else //not masked, and not stretched; just blit
7798 {
7799
7800 if ( rot == 0 ) //if not rotated
7801 {
7802 switch(mode)
7803 {
7804 case 1:
7805 //transparent
7806 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7807 draw_trans_sprite(destBMP, subBmp, dx, dy);
7808 break;
7809
7810
7811 case 2:
7812 //pivot?
7813 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7814 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7815 //Pivoting requires two more args
7816 break;
7817
7818 case 3:
7819 //pivot + trans
7820 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7821 pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7822 break;
7823
7824 case 4:
7825 //flip v
7826 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7827 draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7828 break;
7829
7830 case 5:
7831 //trans + v flip
7832 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7833 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7834 break;
7835
7836 case 6:
7837 //pivot + v flip
7838 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7839 pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7840 break;
7841
7842 case 8:
7843 //vlip h
7844 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7845 draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7846 break;
7847
7848 case 9:
7849 //trans + h flip
7850 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7851 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7852 break;
7853
7854 case 10:
7855 //flip H and pivot
7856 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7857 //return error cannot pivot and h flip
7858 break;
7859
7860 case 12:
7861 //vh flip
7862 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7863 draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7864 break;
7865
7866 case 13:
7867 //trans + vh flip
7868 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7869 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7870 break;
7871
7872 case 14:
7873 //pivot and vh flip
7874 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7875 //return error cannot both pivot and vh flip
7876 break;
7877
7878 case 16:
7879 //lit
7880 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7881 draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7882 break;
7883
7884 case 18:
7885 //pivot, lit
7886 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7887 pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7888 break;
7889
7890 case 20:
7891 //lit + v flip
7892 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7893 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7894 break;
7895
7896 case 22:
7897 //Pivot, vflip, lit
7898 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7899 pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7900 break;
7901
7902 case 24:
7903 //lit + h flip
7904 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7905 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7906 break;
7907
7908 case 26:
7909 //pivot + lit + hflip
7910 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7911 //return error cannot pivot, lit, and flip
7912 break;
7913
7914 case 28:
7915 //lit + vh flip
7916 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7917 draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7918 break;
7919
7920 case 32: //gouraud
7921 //Probably not wort supporting.
7922 //blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7923 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7924 break;
7925
7926 case 0:
7927 //no effect
7928 blit(sbmp, destBMP, sx, sy, dx, dy, dw, dh);
7929 break;
7930
7931
7932 default:
7933
7934 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7935
7936
7937 }
7938 } //end if not rotated
7939
7940 if ( rot != 0 ) //if rotated
7941 {
7942 switch(mode)
7943 {
7944 case 1:
7945 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);//transparent
7946 rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7947
7948 break;
7949
7950 case 2:
7951 //pivot?
7952 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7953 pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7954 //Pivoting requires two more args
7955 break;
7956
7957 case 3:
7958 //pivot + trans
7959 //return an error, cannot both rotate and pivot
7960 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7961 break;
7962
7963 case 4:
7964 //flip v
7965 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7966 rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7967 break;
7968
7969 case 5:
7970 //trans + v flip
7971 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7972 rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7973 break;
7974
7975 case 6:
7976 //pivot + v flip
7977 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7978 //return an error, cannot both rotate and pivot
7979 break;
7980
7981 case 8:
7982 //flip h
7983 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7984 //return an error, cannot both rotate and flip H
7985 break;
7986
7987 case 9:
7988 //trans + h flip
7989 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7990 //return an error, cannot rotate and flip a trans sprite
7991 break;
7992
7993 case 10:
7994 //flip H and pivot
7995 //return error cannot pivot and h flip
7996 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7997 break;
7998
7999 case 12:
8000 //vh flip
8001 //return an error, cannot rotate and VH flip a trans sprite
8002 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8003 break;
8004
8005 case 13:
8006 //trans + vh flip
8007 //return an error, cannot rotate and VH flip a trans sprite
8008 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8009 break;
8010
8011 case 14:
8012 //pivot and vh flip
8013 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8014 //return error cannot both pivot and vh flip
8015 break;
8016
8017 case 16:
8018 //lit
8019 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8020 rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8021 break;
8022
8023 case 18:
8024 //pivot, lit
8025 //return an error, cannot both rotate and pivot
8026 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8027 break;
8028
8029 case 20:
8030 //lit + vflip
8031 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8032 rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8033 break;
8034
8035 case 22:
8036 //Pivot, vflip, lit
8037 //return an error, cannot both rotate and pivot
8038 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8039 break;
8040
8041 case 24:
8042 //lit + h flip
8043 //return an error, cannot both rotate and H flip
8044 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8045 break;
8046
8047 case 26:
8048 //pivot + lit + hflip
8049 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8050 //return error cannot pivot, lit, and flip
8051 break;
8052
8053 case 28:
8054 //lit + vh flip
8055 //return an error, cannot both rotate and VH flip
8056 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8057 break;
8058
8059 case 32: //gouraud
8060 //Probably not wort supporting.
8061 //blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8062 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8063 break;
8064
8065 case 0:
8066 //no effect.
8067 blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8068 rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
8069 break;
8070
8071 default:
8072
8073 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8074
8075 }
8076 } //end if rotated
8077 } //end if not masked
8078 } //end if not stretched
8079
8080 //cleanup
8081 if(subBmp)
8082 {
8083 //script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
8084 destroy_bitmap(subBmp);
8085 }
8086 if (sbmp != sourceBitmap)
8087 {
8088 destroy_bitmap(sbmp);
8089 }
8090 }
8091
8092
8093
8094 void bmp_do_blittor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
8095 {
8096 /*
8097 //sdci[1]=layer
8098 //sdci[2]=bitmap target
8099 //
8100 // -2 is the current Render Target
8101 // -1, this is the screen (framebuf).
8102 // 0: Render target 0
8103 // 1: Render target 1
8104 // 2: Render target 2
8105 // 3: Render target 3
8106 // 4: Render target 4
8107 // 5: Render target 5
8108 // 6: Render target 6
8109 // Otherwise: The pointer to a bitmap.
8110
8111 //sdci[3]=sourcex
8112 //sdci[4]=sourcey
8113 //sdci[5]=sourcew
8114 //sdci[6]=sourceh
8115 //sdci[7]=destx
8116 //sdci[8]=desty
8117 //sdci[9]=destw
8118 //sdci[10]=desth
8119 //sdci[11]=rotation/angle
8120 //scdi[12] = pivot cx
8121 //sdci[13] = pivot cy
8122 //scdi[14] = effect flags
8123 //sdci[17] Bitmap Pointer
8124
8125 // ZScript-side constant values:
8126 const int32_t BITDX_NORMAL = 0;
8127 const int32_t BITDX_TRANS = 1; //Translucent
8128 const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
8129 const int32_t BITDX_HFLIP = 4; //Horizontal Flip
8130 const int32_t BITDX_VFLIP = 8; //Vertical Flip.
8131 //Note: Some modes cannot be combined. if a combination is not supported, an error
8132 // detailing this will be shown in allegro.log.
8133
8134 //scdi[15] = litcolour
8135 //The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8136 //not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
8137
8138 //sdci[16]=mask
8139
8140 */
8141
8142 int32_t srcyoffset = yoffset, srcxoffset = xoffset;
8143 int32_t bitmapIndex = sdci[2]/10000;
8144 int32_t usr_bitmap_index = sdci[2]-10;
8145 byte using_user_bitmap = 0;
8146 //Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
8147 //Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
8148 #if LOG_BMPBLIT_LEVEL > 0
8149 Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
8150 #endif
8151 if ( bitmapIndex > 10000 )
8152 {
8153 bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
8154 }
8155 if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
8156 {
8157 bitmapIndex = usr_bitmap_index;
8158 using_user_bitmap = 1;
8159 srcyoffset = 0;
8160 }
8161
8162 int32_t sx = sdci[3]/10000;
8163 int32_t sy = sdci[4]/10000;
8164 int32_t sw = sdci[5]/10000;
8165 //Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
8166 int32_t sh = sdci[6]/10000;
8167 //Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
8168 int32_t dx = sdci[7]/10000;
8169 int32_t dy = sdci[8]/10000;
8170 int32_t dw = sdci[9]/10000;
8171 int32_t dh = sdci[10]/10000;
8172 float rot = sdci[11]/10000;
8173 int32_t cx = sdci[12]/10000;
8174 int32_t cy = sdci[13]/10000;
8175 int32_t mode = sdci[14]/10000;
8176 int32_t litcolour = sdci[15]/10000;
8177 bool masked = (sdci[16] != 0);
8178
8179 int32_t ref = 0;
8180
8181 //These should go down farther, should they not? -V
8182 //dx = dx + xoffset;
8183 //dy = dy + yoffset;
8184
8185 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
8186 if ( (bitmapIndex) != -2 && (bitmapIndex) != -1 ) srcyoffset = 0; //Don't crop.
8187 //Do we need to also check the render target and do the same thing if the
8188 //dest == -2 and the render target is not RT_SCREEN?
8189 dx = dx + xoffset;
8190 dy = dy + yoffset;
8191 sx = sx + srcxoffset;
8192 sy = sy + srcyoffset;
8193
8194 ref = sdci[17];
8195 //Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
8196 ref -=10;
8197 //Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
8198
8199
8200 if ( ref <= 0 )
8201 {
8202 Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
8203 return;
8204 }
8205 BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
8206 #if LOG_BMPBLIT_LEVEL > 0
8207 Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
8208 #endif
8209 if(!sourceBitmap)
8210 {
8211 Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
8212 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
8213 return;
8214 }
8215
8216 BITMAP *destBMP=NULL;
8217 //zprint2("RevBlit bitmap index is: %d\n",bitmapIndex);
8218
8219 switch(bitmapIndex)
8220 {
8221 case -2:
8222 {
8223 int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
8224 //zprint2("current RT is: %d\n", curr_rt);
8225 if ( curr_rt >= 0 && curr_rt < 7 )
8226 destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
8227 else destBMP = bmp; //screen
8228 break;
8229 }
8230 case -1:
8231 destBMP = bmp; //this is framebuf, by default
8232 break;
8233 //zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
8234 //destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
8235 //destBMP = framebuf; //Drawing to the screen.
8236 //break;
8237
8238 //1 through 6 are the old system bitmaps (Render Targets)
8239 case 0:
8240 case 1:
8241 case 2:
8242 case 3:
8243 case 4:
8244 case 5:
8245 case 6:
8246 {
8247 //This gets a render target.
8248 //destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
8249
8250 destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
8251 //sdci[18] = bitmapIndex;
8252 break;
8253 }
8254 //Otherwise, we are using a user-created bitmap, so, get that pointer insted.
8255 default:
8256 {
8257 destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
8258 //sdci[18] = usr_bitmap_index;
8259 if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
8260 {
8261 Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
8262 break;
8263 }
8264 }
8265 //FFCore.get_user_bitmap(bitmapIndex); break;
8266 }
8267
8268 #if LOG_BMPBLIT_LEVEL > 0
8269 Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
8270 #endif
8271
8272
8273 if (!destBMP)
8274 {
8275 Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
8276 Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
8277 return;
8278 }
8279
8280 //bugfix
8281 //sx = vbound(sx, 0, sourceBitmap->w);
8282 #if LOG_BMPBLIT_LEVEL > 0
8283 Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
8284 Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
8285 #endif
8286 //sy = vbound(sy, 0, sourceBitmap->h);
8287 #if LOG_BMPBLIT_LEVEL > 0
8288 Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
8289 Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
8290 #endif
8291 //sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
8292 #if LOG_BMPBLIT_LEVEL > 0
8293 Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
8294 #endif
8295 //sh = vbound(sh, 0, sourceBitmap->h - sy);
8296 #if LOG_BMPBLIT_LEVEL > 0
8297 Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
8298
8299 Z_scripterrlog("Blit %s is: %d\n", "dx", dx);
8300 Z_scripterrlog("Blit %s is: %d\n", "dy", dy);
8301 Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
8302 Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
8303 Z_scripterrlog("Blit %s is: %d\n", "yoffset", yoffset);
8304 #endif
8305 bool stretched = (sw != dw || sh != dh);
8306 //bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
8307 #if LOG_BMPBLIT_LEVEL > 0
8308 Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
8309 #endif
8310 //BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
8311
8312
8313
8314 BITMAP* newDest = sourceBitmap;
8315 BITMAP* newSource = destBMP; //Flip them.
8316
8317 BITMAP* subBmp = 0;
8318
8319 /* IDR what this was. -Z ( 17th April, 2019 )
8320 if ( bitmapIndex == -1 ) {
8321 blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
8322 }
8323 */
8324
8325 if(rot != 0 || mode != 0)
8326 {
8327 subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
8328 clear_bitmap(subBmp);
8329
8330 if(!subBmp)
8331 {
8332 Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
8333 return;
8334 }
8335 }
8336
8337 if (sx + sw > destBMP->w || sy + sh > destBMP->h)
8338 {
8339 newSource = create_bitmap_ex(8, sw, sh);
8340 clear_bitmap(newSource);
8341 blit(destBMP, newSource, sx, sy, 0, 0, std::min(destBMP->w-sx, sw), std::min(destBMP->h-sy, sh));
8342 sx = 0;
8343 sy = 0;
8344 }
8345 //dx = dx + xoffset; //don't do this here!
8346 //dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
8347
8348 if(stretched)
8349 {
8350 if(masked)
8351 { //stretched and masked
8352 if ( rot == 0 )
8353 { //if not rotated
8354 switch(mode)
8355 {
8356 case 1:
8357 //transparent
8358 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8359 draw_trans_sprite(newDest, subBmp, dx, dy);
8360 break;
8361
8362
8363 case 2:
8364 //pivot?
8365 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8366 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8367 //Pivoting requires two more args
8368 break;
8369
8370 case 3:
8371 //pivot + trans
8372 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8373 pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8374 break;
8375
8376 case 4:
8377 //flip v
8378 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8379 draw_sprite_v_flip(newDest, subBmp, dx, dy);
8380 break;
8381
8382 case 5:
8383 //trans + v flip
8384 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8385 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8386 break;
8387
8388 case 6:
8389 //pivot + v flip
8390 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8391 pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8392 break;
8393
8394 case 8:
8395 //vlip h
8396 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8397 draw_sprite_h_flip(newDest, subBmp, dx, dy);
8398 break;
8399
8400 case 9:
8401 //trans + h flip
8402 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8403 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8404 break;
8405
8406 case 10:
8407 //flip H and pivot
8408 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8409 //return error cannot pivot and h flip
8410 break;
8411
8412 case 12:
8413 //vh flip
8414 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8415 draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8416 break;
8417
8418 case 13:
8419 //trans + vh flip
8420 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8421 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8422 break;
8423
8424 case 14:
8425 //pivot and vh flip
8426 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8427 //return error cannot both pivot and vh flip
8428 break;
8429
8430 case 16:
8431 //lit
8432 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8433 draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
8434 break;
8435
8436 case 18:
8437 //pivot, lit
8438 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8439 pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8440 break;
8441
8442 case 20:
8443 //lit + v flip
8444 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8445 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
8446 break;
8447
8448 case 22:
8449 //Pivot, vflip, lit
8450 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8451 pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8452 break;
8453
8454 case 24:
8455 //lit + h flip
8456 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8457 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
8458 break;
8459
8460 case 26:
8461 //pivot + lit + hflip
8462 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
8463 //return error cannot pivot, lit, and flip
8464 break;
8465
8466 case 28:
8467 //lit + vh flip
8468 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8469 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
8470 break;
8471
8472 case 32: //gouraud
8473 //Probably not wort supporting.
8474 //masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8475 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8476 break;
8477
8478 case 0:
8479 //no effect
8480 masked_stretch_blit(newSource, newDest, sx, sy, sw, sh, dx, dy, dw, dh);
8481 break;
8482
8483
8484 default:
8485 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8486
8487
8488 }
8489 } //end if not rotated
8490
8491 if ( rot != 0 ) //if rotated
8492 {
8493 switch(mode)
8494 {
8495 case 1:
8496 //transparent
8497 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8498 rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8499
8500 break;
8501
8502 case 2:
8503 //pivot?
8504 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8505 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8506 //Pivoting requires two more args
8507 break;
8508
8509 case 3:
8510 //pivot + trans
8511 //return an error, cannot both rotate and pivot
8512 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8513 break;
8514
8515 case 4:
8516 //flip v
8517 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8518 rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8519 break;
8520
8521 case 5:
8522 //trans + v flip
8523 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8524 rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8525 break;
8526
8527 case 6:
8528 //pivot + v flip
8529 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8530 //return an error, cannot both rotate and pivot
8531 break;
8532
8533 case 8:
8534 //flip h
8535 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
8536 //return an error, cannot both rotate and flip H
8537 break;
8538
8539 case 9:
8540 //trans + h flip
8541 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
8542 //return an error, cannot rotate and flip a trans sprite
8543 break;
8544
8545 case 10:
8546 //flip H and pivot
8547 //return error cannot pivot and h flip
8548 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8549 break;
8550
8551 case 12:
8552 //vh flip
8553 //return an error, cannot rotate and VH flip a trans sprite
8554 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8555 break;
8556
8557 case 13:
8558 //trans + vh flip
8559 //return an error, cannot rotate and VH flip a trans sprite
8560 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8561 break;
8562
8563 case 14:
8564 //pivot and vh flip
8565 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8566 //return error cannot both pivot and vh flip
8567 break;
8568
8569 case 16:
8570 //lit
8571 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8572 rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8573 break;
8574
8575 case 18:
8576 //pivot, lit
8577 //return an error, cannot both rotate and pivot
8578 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8579 break;
8580
8581 case 20:
8582 //lit + vflip
8583 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8584 rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8585 break;
8586
8587 case 22:
8588 //Pivot, vflip, lit
8589 //return an error, cannot both rotate and pivot
8590 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8591 break;
8592
8593 case 24:
8594 //lit + h flip
8595 //return an error, cannot both rotate and H flip
8596 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8597 break;
8598
8599 case 26:
8600 //pivot + lit + hflip
8601 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8602 //return error cannot pivot, lit, and flip
8603 break;
8604
8605 case 28:
8606 //lit + vh flip
8607 //return an error, cannot both rotate and VH flip
8608 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8609 break;
8610
8611 case 32: //gouraud
8612 //Probably not wort supporting.
8613 //masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8614 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8615 break;
8616
8617 case 0:
8618 //no effect.
8619 masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8620 rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8621 break;
8622
8623 default:
8624 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8625
8626 }
8627 }
8628 } //end if stretched and masked
8629
8630 else //stretched, not masked
8631 {
8632
8633
8634 if ( rot == 0 ) //if not rotated
8635 {
8636 switch(mode)
8637 {
8638 case 1:
8639 //transparent
8640 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8641 draw_trans_sprite(newDest, subBmp, dx, dy);
8642 break;
8643
8644
8645 case 2:
8646 //pivot?
8647 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8648 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8649 //Pivoting requires two more args
8650 break;
8651
8652 case 3:
8653 //pivot + trans
8654 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8655 pivot_sprite_trans(newDest, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
8656 break;
8657
8658 case 4:
8659 //flip v
8660 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8661 draw_sprite_v_flip(newDest, subBmp, dx, dy);
8662 break;
8663
8664 case 5:
8665 //trans + v flip
8666 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8667 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8668 break;
8669
8670 case 6:
8671 //pivot + v flip
8672 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8673 pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8674 break;
8675
8676 case 8:
8677 //vlip h
8678 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8679 draw_sprite_h_flip(newDest, subBmp, dx, dy);
8680 break;
8681
8682 case 9:
8683 //trans + h flip
8684 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8685 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8686 break;
8687
8688 case 10:
8689 //flip H and pivot
8690 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8691 //return error cannot pivot and h flip
8692 break;
8693
8694 case 12:
8695 //vh flip
8696 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8697 draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8698 break;
8699
8700 case 13:
8701 //trans + vh flip
8702 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8703 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8704 break;
8705
8706 case 14:
8707 //pivot and vh flip
8708 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8709 //return error cannot both pivot and vh flip
8710 break;
8711
8712 case 16:
8713 //lit
8714 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8715 draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
8716 break;
8717
8718 case 18:
8719 //pivot, lit
8720 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8721 pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8722 break;
8723
8724 case 20:
8725 //lit + v flip
8726 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8727 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
8728 break;
8729
8730 case 22:
8731 //Pivot, vflip, lit
8732 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8733 pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8734 break;
8735
8736 case 24:
8737 //lit + h flip
8738 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8739 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
8740 break;
8741
8742 case 26:
8743 //pivot + lit + hflip
8744 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
8745 //return error cannot pivot, lit, and flip
8746 break;
8747
8748 case 28:
8749 //lit + vh flip
8750 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8751 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
8752 break;
8753
8754 case 32: //gouraud
8755 //Probably not wort supporting.
8756 //stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8757 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8758 break;
8759
8760 case 0:
8761 //no effect
8762 stretch_blit(newSource, newDest, sx, sy, sw, sh, dx, dy, dw, dh);
8763 break;
8764
8765
8766 default:
8767 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8768
8769
8770 }
8771 } //end if not rotated
8772
8773 if ( rot != 0 ) //if rotated
8774 {
8775 switch(mode)
8776 {
8777 case 1:
8778 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8779 rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8780
8781 break;
8782
8783 case 2:
8784 //pivot?
8785 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8786 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8787 //Pivoting requires two more args
8788 break;
8789
8790 case 3:
8791 //pivot + trans
8792 //return an error, cannot both rotate and pivot
8793 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8794 break;
8795
8796 case 4:
8797 //flip v
8798 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8799 rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8800 break;
8801
8802 case 5:
8803 //trans + v flip
8804 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8805 rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8806 break;
8807
8808 case 6:
8809 //pivot + v flip
8810 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8811 //return an error, cannot both rotate and pivot
8812 break;
8813
8814 case 8:
8815 //flip h
8816 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
8817 //return an error, cannot both rotate and flip H
8818 break;
8819
8820 case 9:
8821 //trans + h flip
8822 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
8823 //return an error, cannot rotate and flip a trans sprite
8824 break;
8825
8826 case 10:
8827 //flip H and pivot
8828 //return error cannot pivot and h flip
8829 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8830 break;
8831
8832 case 12:
8833 //vh flip
8834 //return an error, cannot rotate and VH flip a trans sprite
8835 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8836 break;
8837
8838 case 13:
8839 //trans + vh flip
8840 //return an error, cannot rotate and VH flip a trans sprite
8841 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8842 break;
8843
8844 case 14:
8845 //pivot and vh flip
8846 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8847 //return error cannot both pivot and vh flip
8848 break;
8849
8850 case 16:
8851 //lit
8852 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8853 rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8854 break;
8855
8856 case 18:
8857 //pivot, lit
8858 //return an error, cannot both rotate and pivot
8859 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8860 break;
8861
8862 case 20:
8863 //lit + vflip
8864 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8865 rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8866 break;
8867
8868 case 22:
8869 //Pivot, vflip, lit
8870 //return an error, cannot both rotate and pivot
8871 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8872 break;
8873
8874 case 24:
8875 //lit + h flip
8876 //return an error, cannot both rotate and H flip
8877 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8878 break;
8879
8880 case 26:
8881 //pivot + lit + hflip
8882 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8883 //return error cannot pivot, lit, and flip
8884 break;
8885
8886 case 28:
8887 //lit + vh flip
8888 //return an error, cannot both rotate and VH flip
8889 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8890 break;
8891
8892 case 32: //gouraud
8893 //Probably not wort supporting.
8894 //stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8895 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8896 break;
8897
8898 case 0:
8899 //no effect.
8900 stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8901 rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8902 break;
8903
8904 default:
8905 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8906
8907 }
8908 }
8909
8910 } //end if stretched, but not masked
8911 }
8912 else //not stretched
8913 {
8914
8915 if(masked) //if masked, but not stretched
8916 {
8917
8918 if ( rot == 0 ) //if not rotated
8919 {
8920 switch(mode)
8921 {
8922 case 1:
8923 //transparent
8924 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8925 draw_trans_sprite(newDest, subBmp, dx, dy);
8926 break;
8927
8928
8929 case 2:
8930 //pivot?
8931 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8932 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8933 //Pivoting requires two more args
8934 break;
8935
8936 case 3:
8937 //pivot + trans
8938 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8939 pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8940 break;
8941
8942 case 4:
8943 //flip v
8944 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8945 draw_sprite_v_flip(newDest, subBmp, dx, dy);
8946 break;
8947
8948 case 5:
8949 //trans + v flip
8950 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8951 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8952 break;
8953
8954 case 6:
8955 //pivot + v flip
8956 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8957 pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8958 break;
8959
8960 case 8:
8961 //vlip h
8962 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8963 draw_sprite_h_flip(newDest, subBmp, dx, dy);
8964 break;
8965
8966 case 9:
8967 //trans + h flip
8968 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8969 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8970 break;
8971
8972 case 10:
8973 //flip H and pivot
8974 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8975 //return error cannot pivot and h flip
8976 break;
8977
8978 case 12:
8979 //vh flip
8980 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8981 draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8982 break;
8983
8984 case 13:
8985 //trans + vh flip
8986 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8987 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8988 break;
8989
8990 case 14:
8991 //pivot and vh flip
8992 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8993 //return error cannot both pivot and vh flip
8994 break;
8995
8996 case 16:
8997 //lit
8998 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8999 draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
9000 break;
9001
9002 case 18:
9003 //pivot, lit
9004 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9005 pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9006 break;
9007
9008 case 20:
9009 //lit + v flip
9010 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9011 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
9012 break;
9013
9014 case 22:
9015 //Pivot, vflip, lit
9016 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9017 pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9018 break;
9019
9020 case 24:
9021 //lit + h flip
9022 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9023 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
9024 break;
9025
9026 case 26:
9027 //pivot + lit + hflip
9028 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
9029 //return error cannot pivot, lit, and flip
9030 break;
9031
9032 case 28:
9033 //lit + vh flip
9034 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9035 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
9036 break;
9037
9038 case 32: //gouraud
9039 //Probably not wort supporting.
9040 //stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
9041 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9042 break;
9043
9044 case 0:
9045 //no effect
9046 masked_blit(newSource, newDest, sx, sy, dx, dy, dw, dh);
9047 break;
9048
9049
9050 default:
9051 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9052
9053
9054 }
9055 } //end if not rotated
9056
9057 if ( rot != 0 ) //if rotated
9058 {
9059 switch(mode)
9060 {
9061 case 1:
9062 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh); //transparent
9063 rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9064
9065 break;
9066
9067 case 2:
9068 //pivot?
9069 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9070 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9071 //Pivoting requires two more args
9072 break;
9073
9074 case 3:
9075 //pivot + trans
9076 //return an error, cannot both rotate and pivot
9077 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9078 break;
9079
9080 case 4:
9081 //flip v
9082 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9083 rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9084 break;
9085
9086 case 5:
9087 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
9088 rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9089 break;
9090
9091 case 6:
9092 //pivot + v flip
9093 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9094 //return an error, cannot both rotate and pivot
9095 break;
9096
9097 case 8:
9098 //flip h
9099 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
9100 //return an error, cannot both rotate and flip H
9101 break;
9102
9103 case 9:
9104 //trans + h flip
9105 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
9106 //return an error, cannot rotate and flip a trans sprite
9107 break;
9108
9109 case 10:
9110 //flip H and pivot
9111 //return error cannot pivot and h flip
9112 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9113 break;
9114
9115 case 12:
9116 //vh flip
9117 //return an error, cannot rotate and VH flip a trans sprite
9118 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9119 break;
9120
9121 case 13:
9122 //trans + vh flip
9123 //return an error, cannot rotate and VH flip a trans sprite
9124 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9125 break;
9126
9127 case 14:
9128 //pivot and vh flip
9129 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9130 //return error cannot both pivot and vh flip
9131 break;
9132
9133 case 16:
9134 //lit
9135 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9136 rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9137 break;
9138
9139 case 18:
9140 //pivot, lit
9141 //return an error, cannot both rotate and pivot
9142 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9143 break;
9144
9145 case 20:
9146 //lit + vflip
9147 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9148 rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9149 break;
9150
9151 case 22:
9152 //Pivot, vflip, lit
9153 //return an error, cannot both rotate and pivot
9154 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9155 break;
9156
9157 case 24:
9158 //lit + h flip
9159 //return an error, cannot both rotate and H flip
9160 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
9161 break;
9162
9163 case 26:
9164 //pivot + lit + hflip
9165 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
9166 //return error cannot pivot, lit, and flip
9167 break;
9168
9169 case 28:
9170 //lit + vh flip
9171 //return an error, cannot both rotate and VH flip
9172 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9173 break;
9174
9175 case 32: //gouraud
9176 //Probably not wort supporting.
9177 //stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
9178 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9179 break;
9180
9181 case 0:
9182 //no effect.
9183 masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9184 rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9185 break;
9186
9187 default:
9188 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9189
9190 }
9191 } //end rtated, masked
9192 } //end if masked
9193
9194 else //not masked, and not stretched; just blit
9195 {
9196
9197 if ( rot == 0 ) //if not rotated
9198 {
9199 switch(mode)
9200 {
9201 case 1:
9202 //transparent
9203 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9204 draw_trans_sprite(newDest, subBmp, dx, dy);
9205 break;
9206
9207
9208 case 2:
9209 //pivot?
9210 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9211 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9212 //Pivoting requires two more args
9213 break;
9214
9215 case 3:
9216 //pivot + trans
9217 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9218 pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9219 break;
9220
9221 case 4:
9222 //flip v
9223 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9224 draw_sprite_v_flip(newDest, subBmp, dx, dy);
9225 break;
9226
9227 case 5:
9228 //trans + v flip
9229 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9230 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
9231 break;
9232
9233 case 6:
9234 //pivot + v flip
9235 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9236 pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9237 break;
9238
9239 case 8:
9240 //vlip h
9241 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9242 draw_sprite_h_flip(newDest, subBmp, dx, dy);
9243 break;
9244
9245 case 9:
9246 //trans + h flip
9247 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9248 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
9249 break;
9250
9251 case 10:
9252 //flip H and pivot
9253 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9254 //return error cannot pivot and h flip
9255 break;
9256
9257 case 12:
9258 //vh flip
9259 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9260 draw_sprite_vh_flip(newDest, subBmp, dx, dy);
9261 break;
9262
9263 case 13:
9264 //trans + vh flip
9265 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9266 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
9267 break;
9268
9269 case 14:
9270 //pivot and vh flip
9271 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9272 //return error cannot both pivot and vh flip
9273 break;
9274
9275 case 16:
9276 //lit
9277 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9278 draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
9279 break;
9280
9281 case 18:
9282 //pivot, lit
9283 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9284 pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9285 break;
9286
9287 case 20:
9288 //lit + v flip
9289 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9290 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
9291 break;
9292
9293 case 22:
9294 //Pivot, vflip, lit
9295 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9296 pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9297 break;
9298
9299 case 24:
9300 //lit + h flip
9301 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9302 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
9303 break;
9304
9305 case 26:
9306 //pivot + lit + hflip
9307 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
9308 //return error cannot pivot, lit, and flip
9309 break;
9310
9311 case 28:
9312 //lit + vh flip
9313 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9314 draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
9315 break;
9316
9317 case 32: //gouraud
9318 //Probably not wort supporting.
9319 //blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9320 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9321 break;
9322
9323 case 0:
9324 //no effect
9325 blit(newSource, newDest, sx, sy, dx, dy, dw, dh);
9326 break;
9327
9328
9329 default:
9330 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9331
9332
9333 }
9334 } //end if not rotated
9335
9336 if ( rot != 0 ) //if rotated
9337 {
9338 switch(mode)
9339 {
9340 case 1:
9341 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);//transparent
9342 rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9343
9344 break;
9345
9346 case 2:
9347 //pivot?
9348 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9349 pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9350 //Pivoting requires two more args
9351 break;
9352
9353 case 3:
9354 //pivot + trans
9355 //return an error, cannot both rotate and pivot
9356 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9357 break;
9358
9359 case 4:
9360 //flip v
9361 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9362 rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9363 break;
9364
9365 case 5:
9366 //trans + v flip
9367 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9368 rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9369 break;
9370
9371 case 6:
9372 //pivot + v flip
9373 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9374 //return an error, cannot both rotate and pivot
9375 break;
9376
9377 case 8:
9378 //flip h
9379 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
9380 //return an error, cannot both rotate and flip H
9381 break;
9382
9383 case 9:
9384 //trans + h flip
9385 Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
9386 //return an error, cannot rotate and flip a trans sprite
9387 break;
9388
9389 case 10:
9390 //flip H and pivot
9391 //return error cannot pivot and h flip
9392 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9393 break;
9394
9395 case 12:
9396 //vh flip
9397 //return an error, cannot rotate and VH flip a trans sprite
9398 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9399 break;
9400
9401 case 13:
9402 //trans + vh flip
9403 //return an error, cannot rotate and VH flip a trans sprite
9404 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9405 break;
9406
9407 case 14:
9408 //pivot and vh flip
9409 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9410 //return error cannot both pivot and vh flip
9411 break;
9412
9413 case 16:
9414 //lit
9415 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9416 rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9417 break;
9418
9419 case 18:
9420 //pivot, lit
9421 //return an error, cannot both rotate and pivot
9422 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9423 break;
9424
9425 case 20:
9426 //lit + vflip
9427 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9428 rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9429 break;
9430
9431 case 22:
9432 //Pivot, vflip, lit
9433 //return an error, cannot both rotate and pivot
9434 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9435 break;
9436
9437 case 24:
9438 //lit + h flip
9439 //return an error, cannot both rotate and H flip
9440 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
9441 break;
9442
9443 case 26:
9444 //pivot + lit + hflip
9445 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
9446 //return error cannot pivot, lit, and flip
9447 break;
9448
9449 case 28:
9450 //lit + vh flip
9451 //return an error, cannot both rotate and VH flip
9452 Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9453 break;
9454
9455 case 32: //gouraud
9456 //Probably not wort supporting.
9457 //blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9458 //draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9459 break;
9460
9461 case 0:
9462 //no effect.
9463 blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9464 rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9465 break;
9466
9467 default:
9468 return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9469
9470 }
9471 } //end if rotated
9472 } //end if not masked
9473 } //end if not stretched
9474
9475 //cleanup
9476 if(subBmp)
9477 {
9478 //script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
9479 destroy_bitmap(subBmp);
9480 }
9481 if(newSource != destBMP)
9482 {
9483 destroy_bitmap(newSource);
9484 }
9485 }
9486
9487
9488 void bmp_do_drawquad3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
9489 {
9490
9491 //sdci[1]=layer
9492 //sdci[2]=pos[12]
9493 //sdci[3]=uv[8]
9494 //sdci[4]=color[4]
9495 //sdci[5]=size[2]
9496 //sdci[6]=flip
9497 //sdci[7]=tile/combo
9498 //sdci[8]=polytype
9499 //sdci[9] = other bitmap as texture
9500 //sdci[17] Bitmap Pointer
9501 if ( sdci[17] <= 0 )
9502 {
9503 Z_scripterrlog("bitmap->Quad3D() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
9504 return;
9505 }
9506 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9507 if ( refbmp == NULL ) return;
9508
9509 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
9510
9511 if(!v_ptr)
9512 {
9513 al_trace("Quad3d: Vector pointer is null! Internal error. \n");
9514 return;
9515 }
9516
9517 std::vector<int32_t> &v = *v_ptr;
9518
9519 if(v.empty())
9520 return;
9521
9522 int32_t* pos = &v[0];
9523 int32_t* uv = &v[12];
9524 int32_t* col = &v[20];
9525 int32_t* size = &v[24];
9526
9527 int32_t w = size[0]; //magic numerical constants... yuck.
9528 int32_t h = size[1];
9529 int32_t flip = (sdci[6]/10000)&3;
9530 int32_t tile = sdci[7]/10000;
9531 int32_t polytype = sdci[8]/10000;
9532 int32_t quad_render_source = sdci[9]-10;
9533 Z_scripterrlog("Quad3D texture is %d\n", quad_render_source);
9534
9535 polytype = vbound(polytype, 0, 14);
9536
9537 int32_t tex_width = w*16;
9538 int32_t tex_height = h*16;
9539
9540 bool mustDestroyBmp = false;
9541 BITMAP *tex=NULL;
9542
9543
9544 bool tex_is_bitmap = ( sdci[9] != 0 );
9545 //Z_scripterrlog("sdci[9] is %d\n", quad_render_source);
9546 //Z_scripterrlog("sdci[17] is %d\n", sdci[17]-10);
9547 BITMAP *bmptexture;
9548
9549 if ( tex_is_bitmap ) bmptexture = FFCore.GetScriptBitmap(quad_render_source);
9550
9551 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9552
9553
9554 if ( !tex_is_bitmap )
9555 {
9556 tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
9557
9558 if(!tex)
9559 {
9560 mustDestroyBmp = true;
9561 tex = create_bitmap_ex(8, tex_width, tex_height);
9562 clear_bitmap(tex);
9563 }
9564 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
9565 {
9566 Z_message("Quad3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
9567 return; //non power of two error
9568 }
9569 if(tile > 0) // TILE
9570 {
9571 TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
9572 }
9573 else // COMBO
9574 {
9575 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
9576 const int32_t tiletodraw = combo_tile(c, 0, 0);
9577 flip = flip ^ c.flip;
9578
9579 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
9580 }
9581
9582 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9583 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9584 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9585 V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
9586
9587 quad3d_f(refbmp, polytype, tex, &V1, &V2, &V3, &V4);
9588 if(mustDestroyBmp)
9589 destroy_bitmap(tex);
9590 }
9591 else
9592 {
9593
9594 if ( !bmptexture )
9595 {
9596 Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Quad3D()");
9597 tex_is_bitmap = 0;
9598 return;
9599 }
9600 if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9601 if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9602 if ( !isPowerOfTwo(h) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", h);
9603 if ( !isPowerOfTwo(w) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", w);
9604
9605 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9606 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9607 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9608 V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
9609
9610 BITMAP *foo = create_bitmap_ex(8, 256, 176);
9611
9612 //quad3d_f(refbmp, polytype, foo, &V1, &V2, &V3, &V4);
9613 quad3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3, &V4);
9614 destroy_bitmap(foo);
9615
9616 }
9617
9618
9619
9620 }
9621
9622
9623
9624 void bmp_do_drawtriangle3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
9625 {
9626 //sdci[1]=layer
9627 //sdci[2]=pos[9]
9628 //sdci[3]=uv[6]
9629 //sdci[4]=color[3]
9630 //sdci[5]=size[2]
9631 //sdci[6]=flip
9632 //sdci[7]=tile/combo
9633 //sdci[8]=polytype
9634 //sdci[9] bitmap as texture
9635 //sdci[17] Bitmap Pointer
9636 if ( sdci[17] <= 0 )
9637 {
9638 Z_scripterrlog("bitmap->Triangle3D() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
9639 return;
9640 }
9641 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9642 if ( refbmp == NULL ) return;
9643
9644 std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
9645
9646 if(!v_ptr)
9647 {
9648 al_trace("bitmap->Triangle3d: Vector pointer is null! Internal error. \n");
9649 return;
9650 }
9651
9652 std::vector<int32_t> &v = *v_ptr;
9653
9654 if(v.empty())
9655 return;
9656
9657 int32_t* pos = &v[0];
9658 int32_t* uv = &v[9];
9659 int32_t* col = &v[15];
9660 int32_t* size = &v[18];
9661
9662 int32_t w = size[0]; //magic numerical constants... yuck.
9663 int32_t h = size[1];
9664 int32_t flip = (sdci[6]/10000)&3;
9665 int32_t tile = sdci[7]/10000;
9666 int32_t polytype = sdci[8]/10000;
9667 int32_t quad_render_source = sdci[9]-10;
9668 polytype = vbound(polytype, 0, 14);
9669
9670 if(((w-1) & w) != 0 || ((h-1) & h) != 0)
9671 {
9672 Z_message("bitmap->Triangle3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
9673 return; //non power of two error
9674 }
9675
9676 int32_t tex_width = w*16;
9677 int32_t tex_height = h*16;
9678
9679 bool mustDestroyBmp = false;
9680 BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
9681
9682 if(!tex)
9683 {
9684 mustDestroyBmp = true;
9685 tex = create_bitmap_ex(8, tex_width, tex_height);
9686 clear_bitmap(tex);
9687 }
9688
9689 bool tex_is_bitmap = ( sdci[9] != 0 );
9690 BITMAP *bmptexture=NULL;
9691 if ( tex_is_bitmap )
9692 {
9693 bmptexture = FFCore.GetScriptBitmap(quad_render_source);
9694 if ( !bmptexture )
9695 {
9696 Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
9697 tex_is_bitmap = 0;
9698 }
9699 }
9700
9701 if ( !tex_is_bitmap )
9702 {
9703 if(tile > 0) // TILE
9704 {
9705 TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
9706 }
9707 else // COMBO
9708 {
9709 const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
9710 const int32_t tiletodraw = combo_tile(c, 0, 0);
9711 flip = flip ^ c.flip;
9712
9713 TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
9714 }
9715
9716 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9717 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9718 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9719
9720 triangle3d_f(refbmp, polytype, tex, &V1, &V2, &V3);
9721 }
9722 else
9723 {
9724 if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9725 if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9726 if ( !isPowerOfTwo(w) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", w);
9727 if ( !isPowerOfTwo(h) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", h);
9728
9729 V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9730 V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9731 V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9732
9733 triangle3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3);
9734
9735
9736 }
9737 if(mustDestroyBmp)
9738 destroy_bitmap(tex);
9739
9740 }
9741
9742
9743 bool is_layer_transparent(const mapscr& m, int32_t layer)
9744 {
9745 layer = vbound(layer, 0, 5);
9746 return m.layeropacity[layer] == 128;
9747 }
9748
9749 mapscr *getmapscreen(int32_t map_index, int32_t screen_index, int32_t layer) //returns NULL for invalid or non-existent layer
9750 {
9751 mapscr *base_screen;
9752 int32_t index = map_index*MAPSCRS+screen_index;
9753
9754 if((uint32_t)layer > 6 || (uint32_t)index >= TheMaps.size())
9755 return NULL;
9756
9757 if(layer != 0)
9758 {
9759 layer = layer - 1;
9760
9761 base_screen=&(TheMaps[index]);
9762
9763 if(base_screen->layermap[layer]==0)
9764 return NULL;
9765
9766 index=(base_screen->layermap[layer]-1)*MAPSCRS+base_screen->layerscreen[layer];
9767
9768 if((uint32_t)index >= TheMaps.size()) // Might as well make sure
9769 return NULL;
9770 }
9771
9772 return &(TheMaps[index]);
9773 }
9774
9775 void draw_mapscr(BITMAP *b, const mapscr& m, int32_t x, int32_t y, bool transparent)
9776 {
9777 for(int32_t i(0); i < 176; ++i)
9778 {
9779 const int32_t x2 = ((i&15)<<4) + x;
9780 const int32_t y2 = (i&0xF0) + y;
9781
9782 //const newcombo & c = combobuf[ m.data[i] ];
9783 /*
9784 newcombo c = combobuf[m.data[i]];
9785 int32_t csets[4];
9786 int32_t cofs = c.csets&15;
9787
9788 if(cofs&8)
9789 cofs |= ~int32_t(0xF);
9790
9791 for(int32_t i=0; i<4; ++i)
9792 csets[i] = c.csets&(16<<i) ? cset + cofs : cset;
9793
9794
9795 const int32_t tile = combo_tile(c, x2, y2);
9796 */
9797
9798 if(transparent)
9799 {
9800 //void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
9801 overcomboblocktranslucent(b, x2, y2, m.data[i], m.cset[i], 1, 1, 128);
9802 //overtiletranslucent16(b, tile, x2, y2, m.cset[i], c.flip, 128);
9803 }
9804 else
9805 {
9806 //overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
9807 overcomboblock(b, x2, y2, m.data[i], m.cset[i], 1, 1);
9808 //overtile16(b, tile, x2, y2, m.cset[i], c.flip);
9809 }
9810 }
9811 }
9812
9813 void draw_map_solidity(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
9814 {
9815 BITMAP* square = create_bitmap_ex(8,16,16);
9816
9817 for(int32_t i(0); i < 176; ++i)
9818 {
9819 const int32_t x2 = ((i&15)<<4) + x;
9820 const int32_t y2 = (i&0xF0) + y;
9821 //Blit the palette index of the solidity value.
9822 //int32_t col = (combobuf[m.data[i]].walk&15);
9823 //if ( col != 0 )
9824 //{
9825 // Z_scripterrlog("Position %d has a solidity value of %d.\n", i, col);
9826 //
9827 //}
9828 clear_to_color(square,(combobuf[m.data[i]].walk&15));
9829 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
9830 else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
9831 }
9832 destroy_bitmap(square);
9833 }
9834
9835 void do_bmpdrawscreen_solidmaskr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
9836 {
9837 //sdci[1]=layer
9838 //sdci[2]=map
9839 //sdci[3]=screen
9840 //sdci[4]=x
9841 //sdci[5]=y
9842 //sdci[6]=rotation
9843 //sdci[17] Bitmap Pointer
9844
9845 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9846 if ( refbmp == NULL ) return;
9847
9848 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9849
9850 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
9851 int32_t scrn = sdci[3]/10000;
9852 int32_t x = sdci[4]/10000;
9853 int32_t y = sdci[5]/10000;
9854 int32_t x1 = x + xoffset;
9855 int32_t y1 = y + yoffset;
9856 int32_t rotation = sdci[6]/10000;
9857
9858 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
9859
9860 if(index >= TheMaps.size())
9861 {
9862 al_trace("DrawScreen: invalid map or screen index. \n");
9863 return;
9864 }
9865
9866 const mapscr & m = TheMaps[index];
9867
9868
9869 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
9870 if ( refbmp == NULL ) return;
9871
9872 if(rotation != 0)
9873 b = script_drawing_commands.AquireSubBitmap(256, 176);
9874
9875 //draw layer 0
9876 draw_map_solidity(b, m, x1, y1);
9877 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
9878 {
9879 for(int32_t i(0); i < 6; ++i)
9880 {
9881 if(m.layermap[i] == 0) continue;
9882
9883 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
9884
9885 if(layer_screen_index >= TheMaps.size())
9886 continue;
9887
9888 //draw valid layers
9889 draw_map_solidity(b, TheMaps[ layer_screen_index ], x1, y1);
9890 }
9891 }
9892
9893 if(rotation != 0) // rotate
9894 {
9895 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
9896 script_drawing_commands.ReleaseSubBitmap(b);
9897 }
9898 }
9899
9900 void draw_map_solid(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
9901 {
9902 BITMAP* square = create_bitmap_ex(8,16,16);
9903 BITMAP* subsquare = create_bitmap_ex(8,16,16);
9904 clear_to_color(subsquare,1);
9905
9906 for(int32_t i(0); i < 176; ++i)
9907 {
9908 const int32_t x2 = ((i&15)<<4) + x;
9909 const int32_t y2 = (i&0xF0) + y;
9910 //Blit the palette index of the solidity value.
9911 //int32_t col = (combobuf[m.data[i]].walk&15);
9912 //if ( col != 0 )
9913 //{
9914 // Z_scripterrlog("Position %d has a solidity value of %d.\n", i, col);
9915 //
9916 //}
9917 clear_bitmap(square);
9918 int32_t sol = (combobuf[m.data[i]].walk);
9919 //al_trace("Solidity is: %d.\n", sol);
9920 if ( sol & 1 )
9921 {
9922 blit(subsquare, square, 0, 0, 0, 0, 8, 8);
9923 }
9924 if ( sol & 2 )
9925 {
9926 blit(subsquare, square, 0, 0, 0, 8, 8, 8);
9927 }
9928 if ( sol & 4 )
9929 {
9930 blit(subsquare, square, 0, 0, 8, 0, 8, 8);
9931 }
9932 if ( sol &8 ) {
9933 blit(subsquare, square, 0, 0, 8, 8, 8, 8);
9934 }
9935
9936 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
9937 else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
9938 }
9939 destroy_bitmap(square);
9940 destroy_bitmap(subsquare);
9941 }
9942
9943 void do_bmpdrawscreen_solidr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
9944 {
9945 //sdci[1]=layer
9946 //sdci[2]=map
9947 //sdci[3]=screen
9948 //sdci[4]=x
9949 //sdci[5]=y
9950 //sdci[6]=rotation
9951 //sdci[17] Bitmap Pointer
9952
9953 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9954 if ( refbmp == NULL ) return;
9955
9956 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9957
9958 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
9959 int32_t scrn = sdci[3]/10000;
9960 int32_t x = sdci[4]/10000;
9961 int32_t y = sdci[5]/10000;
9962 int32_t x1 = x + xoffset;
9963 int32_t y1 = y + yoffset;
9964 int32_t rotation = sdci[6]/10000;
9965
9966 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
9967
9968 if(index >= TheMaps.size())
9969 {
9970 al_trace("DrawScreen: invalid map or screen index. \n");
9971 return;
9972 }
9973
9974 const mapscr & m = TheMaps[index];
9975
9976
9977 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
9978 if ( refbmp == NULL ) return;
9979
9980 if(rotation != 0)
9981 b = script_drawing_commands.AquireSubBitmap(256, 176);
9982
9983 //draw layer 0
9984 draw_map_solid(b, m, x1, y1);
9985
9986 for(int32_t i(0); i < 6; ++i) //This one doesn't need the QR; it works just fine.
9987 {
9988 if(m.layermap[i] == 0) continue;
9989
9990 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
9991
9992 if(layer_screen_index >= TheMaps.size())
9993 continue;
9994
9995 //draw valid layers
9996 draw_map_solid(b, TheMaps[ layer_screen_index ], x1, y1);
9997 }
9998
9999 if(rotation != 0) // rotate
10000 {
10001 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10002 script_drawing_commands.ReleaseSubBitmap(b);
10003 }
10004 }
10005
10006 void draw_map_cflag(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10007 {
10008 BITMAP* square = create_bitmap_ex(8,16,16);
10009
10010 for(int32_t i(0); i < 176; ++i)
10011 {
10012 const int32_t x2 = ((i&15)<<4) + x;
10013 const int32_t y2 = (i&0xF0) + y;
10014 //Blit the palette index of the solidity value.
10015 clear_to_color(square,m.sflag[i]);
10016 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10017 else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10018 }
10019 destroy_bitmap(square);
10020 }
10021
10022 void do_bmpdrawscreen_cflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10023 {
10024 //sdci[1]=layer
10025 //sdci[2]=map
10026 //sdci[3]=screen
10027 //sdci[4]=x
10028 //sdci[5]=y
10029 //sdci[6]=rotation
10030 //sdci[17] Bitmap Pointer
10031
10032 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10033 if ( refbmp == NULL ) return;
10034
10035 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10036
10037 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10038 int32_t scrn = sdci[3]/10000;
10039 int32_t x = sdci[4]/10000;
10040 int32_t y = sdci[5]/10000;
10041 int32_t x1 = x + xoffset;
10042 int32_t y1 = y + yoffset;
10043 int32_t rotation = sdci[6]/10000;
10044
10045 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10046
10047 if(index >= TheMaps.size())
10048 {
10049 al_trace("DrawScreen: invalid map or screen index. \n");
10050 return;
10051 }
10052
10053 const mapscr & m = TheMaps[index];
10054
10055
10056 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10057 if ( refbmp == NULL ) return;
10058
10059 if(rotation != 0)
10060 b = script_drawing_commands.AquireSubBitmap(256, 176);
10061
10062 //draw layer 0
10063 draw_map_cflag(b, m, x1, y1);
10064 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10065 {
10066 for(int32_t i(0); i < 6; ++i)
10067 {
10068 if(m.layermap[i] == 0) continue;
10069
10070 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10071
10072 if(layer_screen_index >= TheMaps.size())
10073 continue;
10074
10075 //draw valid layers
10076 draw_map_cflag(b, TheMaps[ layer_screen_index ], x1, y1);
10077 }
10078 }
10079
10080 if(rotation != 0) // rotate
10081 {
10082 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10083 script_drawing_commands.ReleaseSubBitmap(b);
10084 }
10085 }
10086
10087
10088 void draw_map_combotype(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10089 {
10090 BITMAP* square = create_bitmap_ex(8,16,16);
10091
10092 for(int32_t i(0); i < 176; ++i)
10093 {
10094 const int32_t x2 = ((i&15)<<4) + x;
10095 const int32_t y2 = (i&0xF0) + y;
10096 //Blit the palette index of the solidity value.
10097 clear_to_color(square,(combobuf[m.data[i]].type));
10098 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10099 else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10100 }
10101 destroy_bitmap(square);
10102 }
10103
10104 void do_bmpdrawscreen_ctyper(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10105 {
10106 //sdci[1]=layer
10107 //sdci[2]=map
10108 //sdci[3]=screen
10109 //sdci[4]=x
10110 //sdci[5]=y
10111 //sdci[6]=rotation
10112 //sdci[17] Bitmap Pointer
10113
10114 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10115 if ( refbmp == NULL ) return;
10116
10117 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10118
10119 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10120 int32_t scrn = sdci[3]/10000;
10121 int32_t x = sdci[4]/10000;
10122 int32_t y = sdci[5]/10000;
10123 int32_t x1 = x + xoffset;
10124 int32_t y1 = y + yoffset;
10125 int32_t rotation = sdci[6]/10000;
10126
10127 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10128
10129 if(index >= TheMaps.size())
10130 {
10131 al_trace("DrawScreen: invalid map or screen index. \n");
10132 return;
10133 }
10134
10135 const mapscr & m = TheMaps[index];
10136
10137
10138 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10139 if ( refbmp == NULL ) return;
10140
10141 if(rotation != 0)
10142 b = script_drawing_commands.AquireSubBitmap(256, 176);
10143
10144 //draw layer 0
10145 draw_map_combotype(b, m, x1, y1);
10146
10147 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10148 {
10149 for(int32_t i(0); i < 6; ++i)
10150 {
10151 if(m.layermap[i] == 0) continue;
10152
10153 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10154
10155 if(layer_screen_index >= TheMaps.size())
10156 continue;
10157
10158 //draw valid layers
10159 draw_map_combotype(b, TheMaps[ layer_screen_index ], x1, y1);
10160 }
10161 }
10162
10163 if(rotation != 0) // rotate
10164 {
10165 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10166 script_drawing_commands.ReleaseSubBitmap(b);
10167 }
10168 }
10169
10170
10171 void draw_map_comboiflag(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10172 {
10173 BITMAP* square = create_bitmap_ex(8,16,16);
10174
10175 for(int32_t i(0); i < 176; ++i)
10176 {
10177 const int32_t x2 = ((i&15)<<4) + x;
10178 const int32_t y2 = (i&0xF0) + y;
10179 //Blit the palette index of the solidity value.
10180 clear_to_color(square,(combobuf[m.data[i]].flag));
10181 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10182 else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10183 }
10184 destroy_bitmap(square);
10185 }
10186
10187 void do_bmpdrawscreen_ciflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10188 {
10189 //sdci[1]=layer
10190 //sdci[2]=map
10191 //sdci[3]=screen
10192 //sdci[4]=x
10193 //sdci[5]=y
10194 //sdci[6]=rotation
10195 //sdci[17] Bitmap Pointer
10196
10197 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10198 if ( refbmp == NULL ) return;
10199
10200 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10201
10202 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10203 int32_t scrn = sdci[3]/10000;
10204 int32_t x = sdci[4]/10000;
10205 int32_t y = sdci[5]/10000;
10206 int32_t x1 = x + xoffset;
10207 int32_t y1 = y + yoffset;
10208 int32_t rotation = sdci[6]/10000;
10209
10210 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10211
10212 if(index >= TheMaps.size())
10213 {
10214 al_trace("DrawScreen: invalid map or screen index. \n");
10215 return;
10216 }
10217
10218 const mapscr & m = TheMaps[index];
10219
10220
10221 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10222 if ( refbmp == NULL ) return;
10223
10224 if(rotation != 0)
10225 b = script_drawing_commands.AquireSubBitmap(256, 176);
10226
10227 //draw layer 0
10228 draw_map_comboiflag(b, m, x1, y1);
10229
10230 if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10231 {
10232 for(int32_t i(0); i < 6; ++i)
10233 {
10234 if(m.layermap[i] == 0) continue;
10235
10236 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10237
10238 if(layer_screen_index >= TheMaps.size())
10239 continue;
10240
10241 //draw valid layers
10242 draw_map_comboiflag(b, TheMaps[ layer_screen_index ], x1, y1);
10243 }
10244 }
10245
10246 if(rotation != 0) // rotate
10247 {
10248 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10249 script_drawing_commands.ReleaseSubBitmap(b);
10250 }
10251 }
10252
10253 void do_drawlayerr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10254 {
10255 //sdci[1]=layer
10256 //sdci[2]=map
10257 //sdci[3]=screen
10258 //sdci[4]=layer
10259 //sdci[5]=x
10260 //sdci[6]=y
10261 //sdci[7]=rotation
10262 //sdci[8]=opacity
10263
10264 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10265 int32_t scrn = sdci[3]/10000;
10266 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10267 int32_t x = sdci[5]/10000;
10268 int32_t y = sdci[6]/10000;
10269 int32_t x1 = x + xoffset;
10270 int32_t y1 = y + yoffset;
10271 int32_t rotation = sdci[7]/10000;
10272 int32_t opacity = sdci[8]/10000;
10273
10274 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10275 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10276
10277 if(!m) //no need to log it.
10278 return;
10279
10280 if(index >= TheMaps.size())
10281 {
10282 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10283 return;
10284 }
10285
10286 const mapscr & l = *m;
10287
10288 BITMAP* b = bmp;
10289
10290 if(rotation != 0)
10291 b = script_drawing_commands.AquireSubBitmap(256, 176);
10292
10293
10294 const int32_t maxX = isOffScreen ? 512 : 256;
10295 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10296 bool transparent = opacity <= 128;
10297
10298 if(rotation != 0) // rotate
10299 {
10300 draw_mapscr(b, l, x1, y1, transparent);
10301
10302 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10303 script_drawing_commands.ReleaseSubBitmap(b);
10304 }
10305 else
10306 {
10307 for(int32_t i(0); i < 176; ++i)
10308 {
10309 const int32_t x2 = ((i&15)<<4) + x1;
10310 const int32_t y2 = (i&0xF0) + y1;
10311
10312 if(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY) //in clipping rect
10313 {
10314 const newcombo & c = combobuf[ l.data[i] ];
10315 const int32_t tile = combo_tile(c, x2, y2);
10316
10317 if(opacity < 128)
10318 {
10319 overcomboblocktranslucent(b, x2, y2, l.data[i], l.cset[i], 1, 1, 128);
10320
10321
10322 //overtiletranslucent16(b, tile, x2, y2, l.cset[i], c.flip, opacity);
10323 }
10324 else
10325 {
10326 overcomboblock(b, x2, y2, l.data[i], l.cset[i], 1, 1);
10327 //overtile16(b, tile, x2, y2, l.cset[i], c.flip);
10328 }
10329 //putcombo( b, xx, yy, l.data[i], l.cset[i] );
10330 }
10331 }
10332 }
10333
10334 //putscr
10335 }
10336
10337
10338
10339 void do_drawscreenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10340 {
10341 //sdci[1]=layer
10342 //sdci[2]=map
10343 //sdci[3]=screen
10344 //sdci[4]=x
10345 //sdci[5]=y
10346 //sdci[6]=rotation
10347
10348 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10349 int32_t scrn = sdci[3]/10000;
10350 int32_t x = sdci[4]/10000;
10351 int32_t y = sdci[5]/10000;
10352 int32_t x1 = x + xoffset;
10353 int32_t y1 = y + yoffset;
10354 int32_t rotation = sdci[6]/10000;
10355
10356 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10357
10358 if(index >= TheMaps.size())
10359 {
10360 al_trace("DrawScreen: invalid map or screen index. \n");
10361 return;
10362 }
10363
10364 const mapscr & m = TheMaps[index];
10365
10366
10367 BITMAP* b = bmp;
10368
10369 if(rotation != 0)
10370 b = script_drawing_commands.AquireSubBitmap(256, 176);
10371
10372 //draw layer 0
10373 draw_mapscr(b, m, x1, y1, false);
10374
10375 for(int32_t i(0); i < 6; ++i)
10376 {
10377 if(m.layermap[i] == 0) continue;
10378
10379 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10380
10381 if(layer_screen_index >= TheMaps.size())
10382 continue;
10383
10384 bool trans = m.layeropacity[i] == 128;
10385
10386 //draw valid layers
10387 draw_mapscr(b, TheMaps[ layer_screen_index ], x1, y1, trans);
10388 }
10389
10390 if(rotation != 0) // rotate
10391 {
10392 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10393 script_drawing_commands.ReleaseSubBitmap(b);
10394 }
10395 }
10396
10397
10398 void do_bmpdrawlayerr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10399 {
10400 //sdci[1]=layer
10401 //sdci[2]=map
10402 //sdci[3]=screen
10403 //sdci[4]=layer
10404 //sdci[5]=x
10405 //sdci[6]=y
10406 //sdci[7]=rotation
10407 //[8] noclip
10408 //sdci[9]=opacity
10409 //sdci[17] Bitmap Pointer
10410
10411 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10412 if ( refbmp == NULL ) return;
10413
10414 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10415 int32_t scrn = sdci[3]/10000;
10416 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10417 int32_t x = sdci[5]/10000;
10418 int32_t y = sdci[6]/10000;
10419 int32_t rotation = sdci[7]/10000;
10420
10421 byte noclip = 0;//(sdci[8]!=0);
10422 int32_t opacity = sdci[8]/10000;
10423 //zprint2("Running bmp->DrawLayer(%d, %d, %d, %d, %d, %d, %d, %d)\n", sdci[1]/10000, map, scrn, sourceLayer, x, y, rotation, opacity);
10424 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10425 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10426
10427 if(!m) //no need to log it.
10428 return;
10429
10430 if(index >= TheMaps.size())
10431 {
10432 Z_scripterrlog("DrawLayer: invalid map index \"%i\". Map count is %d.\n", index, TheMaps.size());
10433 return;
10434 }
10435
10436 const mapscr & l = *m;
10437
10438 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10439 if ( refbmp == NULL ) return;
10440 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10441 if(rotation != 0)
10442 b = script_drawing_commands.AquireSubBitmap(256, 176);
10443
10444
10445 const int32_t maxX = isOffScreen ? 512 : 256;
10446 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10447 bool transparent = opacity <= 128;
10448
10449 if(rotation != 0) // rotate
10450 {
10451 draw_mapscr(b, l, x, y, transparent);
10452
10453 rotate_sprite(refbmp, b, x, y, degrees_to_fixed(rotation));
10454 script_drawing_commands.ReleaseSubBitmap(b);
10455 }
10456 else
10457 {
10458 for(int32_t i(0); i < 176; ++i)
10459 {
10460 const int32_t x2 = ((i&15)<<4) + x;
10461 const int32_t y2 = (i&0xF0) + y;
10462
10463 //if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10464 {
10465 const newcombo & c = combobuf[ l.data[i] ];
10466 const int32_t tile = combo_tile(c, x2, y2);
10467
10468 if(opacity < 128)
10469 overtiletranslucent16(refbmp, tile, x2, y2, l.cset[i], c.flip, opacity);
10470 else
10471 overtile16(refbmp, tile, x2, y2, l.cset[i], c.flip);
10472
10473 //putcombo( b, xx, yy, l.data[i], l.cset[i] );
10474 }
10475 }
10476 }
10477
10478 //putscr
10479 }
10480
10481
10482
10483 void do_bmpdrawscreenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10484 {
10485 //sdci[1]=layer
10486 //sdci[2]=map
10487 //sdci[3]=screen
10488 //sdci[4]=x
10489 //sdci[5]=y
10490 //sdci[6]=rotation
10491 //sdci[17] Bitmap Pointer
10492
10493 BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10494 if ( refbmp == NULL ) return;
10495
10496 if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10497
10498 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10499 int32_t scrn = sdci[3]/10000;
10500 int32_t x = sdci[4]/10000;
10501 int32_t y = sdci[5]/10000;
10502 int32_t x1 = x + xoffset;
10503 int32_t y1 = y + yoffset;
10504 int32_t rotation = sdci[6]/10000;
10505
10506 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10507
10508 if(index >= TheMaps.size())
10509 {
10510 al_trace("DrawScreen: invalid map or screen index. \n");
10511 return;
10512 }
10513
10514 const mapscr & m = TheMaps[index];
10515
10516
10517 BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10518 if ( refbmp == NULL ) return;
10519
10520 if(rotation != 0)
10521 b = script_drawing_commands.AquireSubBitmap(256, 176);
10522
10523 //draw layer 0
10524 draw_mapscr(b, m, x1, y1, false);
10525
10526 for(int32_t i(0); i < 6; ++i)
10527 {
10528 if(m.layermap[i] == 0) continue;
10529
10530 uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10531
10532 if(layer_screen_index >= TheMaps.size())
10533 continue;
10534
10535 bool trans = m.layeropacity[i] == 128;
10536
10537 //draw valid layers
10538 draw_mapscr(b, TheMaps[ layer_screen_index ], x1, y1, trans);
10539 }
10540
10541 if(rotation != 0) // rotate
10542 {
10543 rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10544 script_drawing_commands.ReleaseSubBitmap(b);
10545 }
10546 }
10547
10548 void do_bmpdrawlayersolidmaskr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10549 {
10550 //sdci[1]=layer
10551 //sdci[2]=map
10552 //sdci[3]=screen
10553 //sdci[4]=layer
10554 //sdci[5]=x
10555 //sdci[6]=y
10556 //sdci[7]=rotation
10557 //sdci[8]=bool noclip
10558 //sdci[9] == opacity
10559
10560 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10561 int32_t scrn = sdci[3]/10000;
10562 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10563 int32_t x = sdci[5]/10000;
10564 int32_t y = sdci[6]/10000;
10565 int32_t x1 = x + xoffset;
10566 int32_t y1 = y + yoffset;
10567 int32_t rotation = sdci[7]/10000;
10568 byte noclip = (sdci[8]!=0);
10569 int32_t opacity = sdci[9]/10000;
10570
10571 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10572 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10573
10574 if(!m) //no need to log it.
10575 return;
10576
10577 if(index >= TheMaps.size())
10578 {
10579 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10580 return;
10581 }
10582
10583 const mapscr & l = *m;
10584
10585 BITMAP* b = bmp;
10586
10587 if(rotation != 0)
10588 b = script_drawing_commands.AquireSubBitmap(256, 176);
10589
10590
10591 const int32_t maxX = isOffScreen ? 512 : 256;
10592 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10593 bool transparent = opacity <= 128;
10594
10595 if(rotation != 0) // rotate
10596 {
10597 draw_map_solid(b, l, x1, y1);
10598
10599 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10600 script_drawing_commands.ReleaseSubBitmap(b);
10601 }
10602 else
10603 {
10604 BITMAP* square = create_bitmap_ex(8,16,16);
10605 BITMAP* subsquare = create_bitmap_ex(8,16,16);
10606 clear_to_color(subsquare,1);
10607 for(int32_t i(0); i < 176; ++i)
10608 {
10609 const int32_t x2 = ((i&15)<<4) + x1;
10610 const int32_t y2 = (i&0xF0) + y1;
10611
10612 if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10613 {
10614 int32_t sol = (combobuf[l.data[i]].walk);
10615
10616 if ( sol & 1 )
10617 {
10618 blit(subsquare, square, 0, 0, 0, 0, 8, 8);
10619 }
10620 if ( sol & 2 )
10621 {
10622 blit(subsquare, square, 0, 0, 0, 8, 8, 8);
10623 }
10624 if ( sol & 4 )
10625 {
10626 blit(subsquare, square, 0, 0, 8, 0, 8, 8);
10627 }
10628 if ( sol &8 ) {
10629 blit(subsquare, square, 0, 0, 8, 8, 8, 8);
10630 }
10631
10632 blit(square, b, 0, 0, x2, y2, square->w, square->h);
10633 }
10634 }
10635 destroy_bitmap(square);
10636 destroy_bitmap(subsquare);
10637 }
10638
10639 //putscr
10640 }
10641
10642 void do_bmpdrawlayersolidityr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10643 {
10644 //sdci[1]=layer
10645 //sdci[2]=map
10646 //sdci[3]=screen
10647 //sdci[4]=layer
10648 //sdci[5]=x
10649 //sdci[6]=y
10650 //sdci[7]=rotation
10651 //[8] noclip
10652 //sdci[9]=opacity
10653
10654
10655 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10656 int32_t scrn = sdci[3]/10000;
10657 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10658 int32_t x = sdci[5]/10000;
10659 int32_t y = sdci[6]/10000;
10660 int32_t x1 = x + xoffset;
10661 int32_t y1 = y + yoffset;
10662 int32_t rotation = sdci[7]/10000;
10663 byte noclip = (sdci[8]!=0);
10664 int32_t opacity = sdci[9]/10000;
10665
10666 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10667 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10668
10669 if(!m) //no need to log it.
10670 return;
10671
10672 if(index >= TheMaps.size())
10673 {
10674 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10675 return;
10676 }
10677
10678 const mapscr & l = *m;
10679
10680 BITMAP* b = bmp;
10681
10682 if(rotation != 0)
10683 b = script_drawing_commands.AquireSubBitmap(256, 176);
10684
10685
10686 const int32_t maxX = isOffScreen ? 512 : 256;
10687 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10688 bool transparent = opacity <= 128;
10689
10690 if(rotation != 0) // rotate
10691 {
10692 draw_map_solidity(b, l, x1, y1);
10693
10694 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10695 script_drawing_commands.ReleaseSubBitmap(b);
10696 }
10697 else
10698 {
10699 BITMAP* square = create_bitmap_ex(8,16,16);
10700 for(int32_t i(0); i < 176; ++i)
10701 {
10702 const int32_t x2 = ((i&15)<<4) + x1;
10703 const int32_t y2 = (i&0xF0) + y1;
10704
10705 if(noclip && (x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10706 {
10707 clear_to_color(square,(combobuf[l.data[i]].walk&15));
10708 blit(square, b, 0, 0, x2, y2, square->w, square->h);
10709 }
10710 }
10711 destroy_bitmap(square);
10712 }
10713
10714 //putscr
10715 }
10716
10717 void do_bmpdrawlayercflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10718 {
10719 //sdci[1]=layer
10720 //sdci[2]=map
10721 //sdci[3]=screen
10722 //sdci[4]=layer
10723 //sdci[5]=x
10724 //sdci[6]=y
10725 //sdci[7]=rotation
10726 //[8] noclip
10727 //sdci[9]=opacity
10728
10729
10730 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10731 int32_t scrn = sdci[3]/10000;
10732 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10733 int32_t x = sdci[5]/10000;
10734 int32_t y = sdci[6]/10000;
10735 int32_t x1 = x + xoffset;
10736 int32_t y1 = y + yoffset;
10737 int32_t rotation = sdci[7]/10000;
10738
10739 byte noclip = (sdci[8]!=0);
10740 int32_t opacity = sdci[9]/10000;
10741
10742 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10743 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10744
10745 if(!m) //no need to log it.
10746 return;
10747
10748 if(index >= TheMaps.size())
10749 {
10750 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10751 return;
10752 }
10753
10754 const mapscr & l = *m;
10755
10756 BITMAP* b = bmp;
10757
10758 if(rotation != 0)
10759 b = script_drawing_commands.AquireSubBitmap(256, 176);
10760
10761
10762 const int32_t maxX = isOffScreen ? 512 : 256;
10763 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10764 bool transparent = opacity <= 128;
10765
10766 if(rotation != 0) // rotate
10767 {
10768 draw_map_cflag(b, l, x1, y1);
10769
10770 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10771 script_drawing_commands.ReleaseSubBitmap(b);
10772 }
10773 else
10774 {
10775 BITMAP* square = create_bitmap_ex(8,16,16);
10776 for(int32_t i(0); i < 176; ++i)
10777 {
10778 const int32_t x2 = ((i&15)<<4) + x1;
10779 const int32_t y2 = (i&0xF0) + y1;
10780
10781 if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10782 {
10783 clear_to_color(square,l.sflag[i]);
10784 blit(square, b, 0, 0, x2, y2, square->w, square->h);
10785 }
10786 }
10787 destroy_bitmap(square);
10788 }
10789
10790 //putscr
10791 }
10792
10793 void do_bmpdrawlayerctyper(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10794 {
10795 //sdci[1]=layer
10796 //sdci[2]=map
10797 //sdci[3]=screen
10798 //sdci[4]=layer
10799 //sdci[5]=x
10800 //sdci[6]=y
10801 //sdci[7]=rotation
10802 //[8] noclip
10803 //sdci[9]=opacity
10804
10805 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10806 int32_t scrn = sdci[3]/10000;
10807 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10808 int32_t x = sdci[5]/10000;
10809 int32_t y = sdci[6]/10000;
10810 int32_t x1 = x + xoffset;
10811 int32_t y1 = y + yoffset;
10812 int32_t rotation = sdci[7]/10000;
10813
10814 byte noclip = (sdci[8]!=0);
10815 int32_t opacity = sdci[9]/10000;
10816 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10817 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10818
10819 if(!m) //no need to log it.
10820 return;
10821
10822 if(index >= TheMaps.size())
10823 {
10824 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10825 return;
10826 }
10827
10828 const mapscr & l = *m;
10829
10830 BITMAP* b = bmp;
10831
10832 if(rotation != 0)
10833 b = script_drawing_commands.AquireSubBitmap(256, 176);
10834
10835
10836 const int32_t maxX = isOffScreen ? 512 : 256;
10837 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10838 bool transparent = opacity <= 128;
10839
10840 if(rotation != 0) // rotate
10841 {
10842 draw_map_combotype(b, l, x1, y1);
10843
10844 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10845 script_drawing_commands.ReleaseSubBitmap(b);
10846 }
10847 else
10848 {
10849 BITMAP* square = create_bitmap_ex(8,16,16);
10850 for(int32_t i(0); i < 176; ++i)
10851 {
10852 const int32_t x2 = ((i&15)<<4) + x1;
10853 const int32_t y2 = (i&0xF0) + y1;
10854
10855 if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10856 {
10857 clear_to_color(square,(combobuf[l.data[i]].type));
10858 blit(square, b, 0, 0, x2, y2, square->w, square->h);
10859 }
10860 }
10861 destroy_bitmap(square);
10862 }
10863
10864 //putscr
10865 }
10866
10867 void do_bmpdrawlayerciflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10868 {
10869 //sdci[1]=layer
10870 //sdci[2]=map
10871 //sdci[3]=screen
10872 //sdci[4]=layer
10873 //sdci[5]=x
10874 //sdci[6]=y
10875 //sdci[7]=rotation
10876 //[8] noclip
10877 //sdci[9]=opacity
10878
10879 int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10880 int32_t scrn = sdci[3]/10000;
10881 int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10882 int32_t x = sdci[5]/10000;
10883 int32_t y = sdci[6]/10000;
10884 int32_t x1 = x + xoffset;
10885 int32_t y1 = y + yoffset;
10886 int32_t rotation = sdci[7]/10000;
10887 byte noclip = (sdci[8]!=0);
10888 int32_t opacity = sdci[9]/10000;
10889
10890 const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10891 const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10892
10893 if(!m) //no need to log it.
10894 return;
10895
10896 if(index >= TheMaps.size())
10897 {
10898 al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10899 return;
10900 }
10901
10902 const mapscr & l = *m;
10903
10904 BITMAP* b = bmp;
10905
10906 if(rotation != 0)
10907 b = script_drawing_commands.AquireSubBitmap(256, 176);
10908
10909
10910 const int32_t maxX = isOffScreen ? 512 : 256;
10911 const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10912 bool transparent = opacity <= 128;
10913
10914 if(rotation != 0) // rotate
10915 {
10916 draw_map_comboiflag(b, l, x1, y1);
10917
10918 rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10919 script_drawing_commands.ReleaseSubBitmap(b);
10920 }
10921 else
10922 {
10923 BITMAP* square = create_bitmap_ex(8,16,16);
10924 for(int32_t i(0); i < 176; ++i)
10925 {
10926 const int32_t x2 = ((i&15)<<4) + x1;
10927 const int32_t y2 = (i&0xF0) + y1;
10928
10929 if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10930 {
10931 clear_to_color(square,(combobuf[l.data[i]].flag));
10932 blit(square, b, 0, 0, x2, y2, square->w, square->h);
10933 }
10934 }
10935 destroy_bitmap(square);
10936 }
10937
10938 //putscr
10939 }
10940
10941
10942
10943 /////////////////////////////////////////////////////////
10944 // do primitives
10945 ////////////////////////////////////////////////////////
10946
10947 18354 void do_primitives(BITMAP *targetBitmap, int32_t type, mapscr* theScreen, int32_t xoff, int32_t yoff)
10948 {
10949 18354 color_map = &trans_table2;
10950
10951 //was this next variable ever used? -- DN
10952 //bool drawsubscr=false;
10953
10954
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18354 times.
18354 if(type > 7)
10955 return;
10956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18354 times.
18354 if(theScreen->hidescriptlayers & (1<<type))
10957 return; //Script draws hidden for this layer
10958 //--script_drawing_commands[][] reference--
10959 //[][0]: type
10960 //[][1-16]: defined by type
10961 //[][17]: unused
10962 //[][18]: rendertarget
10963 //[][19]: unused
10964
10965 // Trying to match the old behavior exactly...
10966
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18354 times.
18354 const bool brokenOffset= ( (get_bit(extra_rules, er_BITMAPOFFSET)!=0) || (get_bit(quest_rules,qr_BITMAPOFFSETFIX)!=0) );
10967
10968 18354 bool isTargetOffScreenBmp = false;
10969 18354 const int32_t type_mul_10000 = type * 10000;
10970 18354 const int32_t numDrawCommandsToProcess = script_drawing_commands.Count();
10971 18354 FFCore.numscriptdraws = numDrawCommandsToProcess;
10972 18354 int32_t xoffset=xoff, yoffset=yoff;
10973
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18354 times.
18354 for(int32_t i(0); i < numDrawCommandsToProcess; ++i)
10974 {
10975 if(!brokenOffset)
10976 {
10977 xoffset = 0;
10978 yoffset = 0;
10979 }
10980 int32_t *sdci = &script_drawing_commands[i][0];
10981
10982 if(sdci[1] != type_mul_10000)
10983 continue;
10984 // get the correct render target, if set.
10985 BITMAP *bmp = zscriptDrawingRenderTarget->GetTargetBitmap(sdci[18]);
10986
10987 if(!bmp)
10988 {
10989 // draw to screen with subscreen offset
10990 if(!brokenOffset)
10991 {
10992 xoffset = xoff;
10993 yoffset = yoff;
10994 }
10995 bmp = targetBitmap;
10996 }
10997 else
10998 {
10999 //not drawing to screen, so no subscreen offset
11000 if(brokenOffset)
11001 {
11002 xoffset = 0;
11003 yoffset = 0;
11004 }
11005 isTargetOffScreenBmp = true;
11006 }
11007
11008 switch(sdci[0])
11009 {
11010 case RECTR:
11011 {
11012 do_rectr(bmp, sdci, xoffset, yoffset);
11013 }
11014 break;
11015 case FRAMER:
11016 {
11017 do_framer(bmp, sdci, xoffset, yoffset);
11018 }
11019 break;
11020
11021
11022 case CIRCLER:
11023 {
11024 do_circler(bmp, sdci, xoffset, yoffset);
11025 }
11026 break;
11027
11028 case ARCR:
11029 {
11030 do_arcr(bmp, sdci, xoffset, yoffset);
11031 }
11032 break;
11033
11034 case ELLIPSER:
11035 {
11036 do_ellipser(bmp, sdci, xoffset, yoffset);
11037 }
11038 break;
11039
11040 case LINER:
11041 {
11042 do_liner(bmp, sdci, xoffset, yoffset);
11043 }
11044 break;
11045
11046 case SPLINER:
11047 {
11048 do_spliner(bmp, sdci, xoffset, yoffset);
11049 }
11050 break;
11051
11052 case PUTPIXELR:
11053 {
11054 do_putpixelr(bmp, sdci, xoffset, yoffset);
11055 }
11056 break;
11057 case PIXELARRAYR:
11058 {
11059 //Z_scripterrlog("Reached case PIXELARRAYR\n");
11060 do_putpixelsr(bmp, i, sdci, xoffset, yoffset);
11061 }
11062 break;
11063
11064 case TILEARRAYR:
11065 {
11066 //Z_scripterrlog("Reached case PIXELARRAYR\n");
11067 do_fasttilesr(bmp, i, sdci, xoffset, yoffset);
11068 }
11069 break;
11070
11071 case LINESARRAY:
11072 {
11073 //Z_scripterrlog("Reached case PIXELARRAYR\n");
11074 do_linesr(bmp, i, sdci, xoffset, yoffset);
11075 }
11076 break;
11077
11078 case COMBOARRAYR:
11079 {
11080 //Z_scripterrlog("Reached case PIXELARRAYR\n");
11081 do_fastcombosr(bmp, i, sdci, xoffset, yoffset);
11082 }
11083 break;
11084
11085
11086
11087 case DRAWTILER:
11088 {
11089 do_drawtiler(bmp, sdci, xoffset, yoffset);
11090 }
11091 break;
11092
11093 case DRAWTILECLOAKEDR:
11094 {
11095 do_drawtilecloakedr(bmp, sdci, xoffset, yoffset);
11096 }
11097 break;
11098
11099 case DRAWCOMBOR:
11100 {
11101 do_drawcombor(bmp, sdci, xoffset, yoffset);
11102 }
11103 break;
11104
11105 case DRAWCOMBOCLOAKEDR:
11106 {
11107 do_drawcombocloakedr(bmp, sdci, xoffset, yoffset);
11108 }
11109 break;
11110
11111 case FASTTILER:
11112 {
11113 do_fasttiler(bmp, sdci, xoffset, yoffset);
11114 }
11115 break;
11116
11117 case FASTCOMBOR:
11118 {
11119 do_fastcombor(bmp, sdci, xoffset, yoffset);
11120 }
11121 break;
11122
11123 case DRAWCHARR:
11124 {
11125 do_drawcharr(bmp, sdci, xoffset, yoffset);
11126 }
11127 break;
11128
11129 case DRAWINTR:
11130 {
11131 do_drawintr(bmp, sdci, xoffset, yoffset);
11132 }
11133 break;
11134
11135 case DRAWSTRINGR:
11136 {
11137 do_drawstringr(bmp, i, sdci, xoffset, yoffset);
11138 }
11139 break;
11140
11141 case DRAWSTRINGR2:
11142 {
11143 do_drawstringr2(bmp, i, sdci, xoffset, yoffset);
11144 }
11145 break;
11146
11147 case QUADR:
11148 {
11149 do_drawquadr(bmp, sdci, xoffset, yoffset);
11150 }
11151 break;
11152
11153 case QUAD3DR:
11154 {
11155 do_drawquad3dr(bmp, i, sdci, xoffset, yoffset);
11156 }
11157 break;
11158
11159 case TRIANGLER:
11160 {
11161 do_drawtriangler(bmp, sdci, xoffset, yoffset);
11162 }
11163 break;
11164
11165 case TRIANGLE3DR:
11166 {
11167 do_drawtriangle3dr(bmp, i, sdci, xoffset, yoffset);
11168 }
11169 break;
11170
11171 case POLYGONR:
11172 {
11173 do_polygonr(bmp, i, sdci, xoffset, yoffset);
11174 }
11175 break;
11176
11177
11178 case BITMAPR:
11179 {
11180 do_drawbitmapr(bmp, sdci, xoffset, yoffset);
11181 }
11182 break;
11183
11184 case BITMAPEXR:
11185 {
11186 do_drawbitmapexr(bmp, sdci, xoffset, yoffset);
11187 }
11188 break;
11189
11190 case DRAWLAYERR:
11191 {
11192 do_drawlayerr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp);
11193 }
11194 break;
11195
11196 case DRAWSCREENR:
11197 {
11198 do_drawscreenr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp);
11199 }
11200 break;
11201
11202 case BMPRECTR: bmp_do_rectr(bmp, sdci, xoffset, yoffset); break;
11203 case BMPFRAMER: bmp_do_framer(bmp, sdci, xoffset, yoffset); break;
11204 case BMPCIRCLER: bmp_do_circler(bmp, sdci, xoffset, yoffset); break;
11205 case BMPARCR: bmp_do_arcr(bmp, sdci, xoffset, yoffset); break;
11206 case BMPELLIPSER: bmp_do_ellipser(bmp, sdci, xoffset, yoffset); break;
11207 case BMPLINER: bmp_do_liner(bmp, sdci, xoffset, yoffset); break;
11208 case BMPSPLINER: bmp_do_spliner(bmp, sdci, xoffset, yoffset); break;
11209 case BMPPUTPIXELR: bmp_do_putpixelr(bmp, sdci, xoffset, yoffset); break;
11210 case BMPDRAWTILER: bmp_do_drawtiler(bmp, sdci, xoffset, yoffset); break;
11211 case BMPDRAWTILECLOAKEDR: bmp_do_drawtilecloakedr(bmp, sdci, xoffset, yoffset); break;
11212 case BMPDRAWCOMBOR: bmp_do_drawcombor(bmp, sdci, xoffset, yoffset); break;
11213 case BMPDRAWCOMBOCLOAKEDR: bmp_do_drawcombocloakedr(bmp, sdci, xoffset, yoffset); break;
11214 case BMPFASTTILER: bmp_do_fasttiler(bmp, sdci, xoffset, yoffset); break;
11215 case BMPFASTCOMBOR: bmp_do_fastcombor(bmp, sdci, xoffset, yoffset); break;
11216 case BMPDRAWCHARR: bmp_do_drawcharr(bmp, sdci, xoffset, yoffset); break;
11217 case BMPDRAWINTR: bmp_do_drawintr(bmp, sdci, xoffset, yoffset); break;
11218 case BMPDRAWSTRINGR: bmp_do_drawstringr(bmp, i, sdci, xoffset, yoffset); break;
11219 case BMPDRAWSTRINGR2: bmp_do_drawstringr2(bmp, i, sdci, xoffset, yoffset); break;
11220 case BMPQUADR: bmp_do_drawquadr(bmp, sdci, xoffset, yoffset); break;
11221 case BMPQUAD3DR: bmp_do_drawquad3dr(bmp, i, sdci, xoffset, yoffset); break;
11222
11223 case BITMAPGETPIXEL: bmp_do_getpixelr(bmp, sdci, xoffset, yoffset); break;
11224 case BMPTRIANGLER: bmp_do_drawtriangler(bmp, sdci, xoffset, yoffset); break;
11225 case BMPTRIANGLE3DR: bmp_do_drawtriangle3dr(bmp, i, sdci, xoffset, yoffset); break;
11226 case BMPPOLYGONR: bmp_do_polygonr(bmp, i, sdci, xoffset, yoffset); break;
11227 case BMPDRAWLAYERR: do_bmpdrawlayerr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11228 case BMPDRAWSCREENR: do_bmpdrawscreenr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11229 case BMPDRAWSCREENSOLIDR: do_bmpdrawscreen_solidmaskr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11230 case BMPDRAWSCREENSOLID2R: do_bmpdrawscreen_solidr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11231 case BMPDRAWSCREENCOMBOFR: do_bmpdrawscreen_cflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11232 case BMPDRAWSCREENCOMBOIR: do_bmpdrawscreen_ciflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11233 case BMPDRAWSCREENCOMBOTR: do_bmpdrawscreen_ctyper(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11234 case BMPBLIT: bmp_do_drawbitmapexr(bmp, sdci, xoffset, yoffset); break;
11235 case BMPMODE7: bmp_do_mode7r(bmp, sdci, xoffset, yoffset); break;
11236 case BMPBLITTO: bmp_do_blittor(bmp, sdci, xoffset, yoffset); break;
11237 case READBITMAP: bmp_do_readr(bmp, i, sdci, xoffset, yoffset); break;
11238 case WRITEBITMAP: bmp_do_writer(bmp, i, sdci, xoffset, yoffset); break;
11239 case CLEARBITMAP: bmp_do_clearr(bmp, sdci, xoffset, yoffset); break;
11240 case BITMAPCLEARTOCOLOR: bmp_do_clearcolorr(bmp, sdci, xoffset, yoffset); break;
11241 case REGENERATEBITMAP: bmp_do_regenr(bmp, sdci, xoffset, yoffset); break;
11242
11243 case BMPDRAWLAYERSOLIDR: do_bmpdrawlayersolidmaskr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11244 case BMPDRAWLAYERCFLAGR: do_bmpdrawlayercflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11245 case BMPDRAWLAYERCTYPER: do_bmpdrawlayerctyper(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11246 case BMPDRAWLAYERCIFLAGR: do_bmpdrawlayerciflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11247 case BMPDRAWLAYERSOLIDITYR: do_bmpdrawlayersolidityr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11248 case BMPWRITETILE: do_bmpwritetile(bmp, sdci, xoffset, yoffset); break;
11249 case BMPDITHER: do_bmpdither(bmp, sdci, xoffset, yoffset); break;
11250 case BMPREPLCOLOR: do_bmpreplcol(bmp, sdci, xoffset, yoffset); break;
11251 case BMPSHIFTCOLOR: do_bmpshiftcol(bmp, sdci, xoffset, yoffset); break;
11252 case BMPMASKDRAW: do_bmpmaskdraw(bmp, sdci, xoffset, yoffset); break;
11253 case BMPMASKBLIT: do_bmpmaskblit(bmp, sdci, xoffset, yoffset); break;
11254 }
11255 }
11256
11257
11258 18354 color_map=&trans_table;
11259 18354 }
11260
11261 2089 void CScriptDrawingCommands::Clear()
11262 {
11263 2089 scb.update();
11264
1/2
✓ Branch 0 taken 2089 times.
✗ Branch 1 not taken.
2089 if(commands.empty())
11265 2089 return;
11266
11267 //only clear what was used.
11268 memset((void*)&commands[0], 0, count * sizeof(CScriptDrawingCommandVars));
11269 count = 0;
11270
11271 draw_container.Clear();
11272 2089 }
11273 CScriptDrawingCommands* CScriptDrawingCommands::pop_commands()
11274 {
11275 CScriptDrawingCommands* ret = new CScriptDrawingCommands();
11276 if(commands.empty())
11277 return ret;
11278 ret->push_commands(this, false);
11279
11280 memset((void*)&commands[0], 0, count * sizeof(CScriptDrawingCommandVars));
11281 count = 0;
11282
11283 draw_container.Clear();
11284 return ret;
11285 }
11286 void CScriptDrawingCommands::push_commands(CScriptDrawingCommands* other, bool del)
11287 {
11288 commands.insert(commands.end(), other->commands.begin(), other->commands.end());
11289 count += other->count;
11290 if(del) delete other;
11291 }
11292
11293 void do_script_draws(BITMAP *targetBitmap, mapscr* theScreen, int32_t xoff, int32_t yoff, bool hideLayer7)
11294 {
11295 if(XOR(theScreen->flags7&fLAYER2BG, DMaps[currdmap].flags&dmfLAYER2BG)) do_primitives(targetBitmap, 2, theScreen, xoff, yoff);
11296 if(XOR(theScreen->flags7&fLAYER3BG, DMaps[currdmap].flags&dmfLAYER3BG)) do_primitives(targetBitmap, 3, theScreen, xoff, yoff);
11297 do_primitives(targetBitmap, 0, theScreen, xoff, yoff);
11298 do_primitives(targetBitmap, 1, theScreen, xoff, yoff);
11299 if(!XOR(theScreen->flags7&fLAYER2BG, DMaps[currdmap].flags&dmfLAYER2BG)) do_primitives(targetBitmap, 2, theScreen, xoff, yoff);
11300 if(!XOR(theScreen->flags7&fLAYER3BG, DMaps[currdmap].flags&dmfLAYER3BG)) do_primitives(targetBitmap, 3, theScreen, xoff, yoff);
11301 do_primitives(targetBitmap, 4, theScreen, xoff, yoff);
11302 do_primitives(targetBitmap, 5, theScreen, xoff, yoff);
11303 do_primitives(targetBitmap, 6, theScreen, xoff, yoff);
11304 if(!hideLayer7) do_primitives(targetBitmap, 7, theScreen, xoff, yoff);
11305 }
11306